@mintlify/cli 4.0.1813 → 4.1.1

package/src/deploy.ts

@@ -1,165 +0,0 @@
-import path from 'node:path';
-
-import {
-  discoverAgentAuth,
-  exchangeAgentToken,
-  getAgentIdentity,
-  registerAgent,
-} from './agent-auth.js';
-import {
-  loadAgentCredentials,
-  saveAgentCredentials,
-  type AgentCredentials,
-} from './agent-credentials.js';
-import {
-  getAgentWriteToken,
-  provisionAgentSite,
-  type AgentProjectType,
-  type AgentSite,
-  type AgentWriteToken,
-} from './agent-deployment.js';
-import { getAgentSiteMetadata, setAgentSiteMetadata } from './config.js';
-import { DASHBOARD_URL } from './constants.js';
-import { trackEvent } from './telemetry/track.js';
-
-export type DeployOptions = {
-  apiUrl: string;
-  directory: string;
-  subdomain?: string;
-  orgName?: string;
-  newSite?: boolean;
-  base?: boolean;
-};
-
-export type DeployResult =
-  | { status: 'claimed' }
-  | {
-      status: 'ready';
-      projectType: AgentProjectType;
-      site: AgentSite;
-      write: AgentWriteToken;
-      created: boolean;
-      credentials: AgentCredentials;
-    };
-
-export async function prepareAgentDeployment(
-  options: DeployOptions,
-  warn: (message: string) => void,
-  progress: (message: string) => void = () => {}
-): Promise<DeployResult> {
-  const { apiUrl } = options;
-  const directory = path.resolve(options.directory);
-  const metadataKey = JSON.stringify([new URL(apiUrl).origin, directory]);
-  const previous = getAgentSiteMetadata(metadataKey);
-  progress('Authenticating agent...');
-  let saved = options.newSite
-    ? null
-    : await loadAgentCredentials(apiUrl, directory).catch(() => {
-        if (previous)
-          throw new Error(
-            'Could not read this site’s saved credentials. Unlock your keyring or use --new for another site.'
-          );
-        warn('Could not read the keyring. Continuing with a new registration for this run.');
-        return null;
-      });
-  const subdomain = options.subdomain ?? (options.newSite ? undefined : previous?.subdomain);
-  if (!subdomain) throw new Error('Choose a site name with --subdomain <name>.');
-  const discovery = await discoverAgentAuth(apiUrl);
-  const projectType: AgentProjectType = options.base ? 'workspace' : 'site';
-
-  const save = (credentials: AgentCredentials) =>
-    saveAgentCredentials(apiUrl, directory, credentials);
-
-  for (let attempt = 0; attempt < 2; attempt++) {
-    const credentials = saved ?? (await registerAgent(discovery));
-    void trackEvent('agent_signup.discovered', { registration_id: credentials.registrationId });
-    if (!saved)
-      void trackEvent('agent_signup.registered', { registration_id: credentials.registrationId });
-    await save(credentials);
-    const authenticated = await exchangeAgentToken(discovery, credentials);
-    await save(authenticated);
-    const identity = await getAgentIdentity(apiUrl, authenticated.accessToken);
-    if (identity.registrationId !== credentials.registrationId)
-      throw new Error('Agent identity does not match the saved registration.');
-    if (identity.identityType === 'user_bound') return { status: 'claimed' };
-    progress(`Provisioning the ${options.base ? 'base' : 'site'} and repository...`);
-    const site = await provisionAgentSite(apiUrl, authenticated.accessToken, {
-      subdomain,
-      orgName: options.orgName,
-      ...(options.base && { projectType }),
-    });
-    if (site.status === 'expired') {
-      warn('The previous anonymous site expired. Creating a new registration and site.');
-      saved = null;
-      continue;
-    }
-    void trackEvent('cli.deploy.provisioned', {
-      registration_id: credentials.registrationId,
-      deployment_id: site.deploymentId,
-      subdomain: site.subdomain,
-      created: site.created,
-    });
-    await setAgentSiteMetadata(metadataKey, {
-      registrationId: credentials.registrationId,
-      subdomain: site.subdomain,
-    }).catch(() =>
-      warn('Could not save the site name locally. Provide --subdomain on your next invocation.')
-    );
-    progress('Getting repository write access...');
-    const write = await getAgentWriteToken(apiUrl, authenticated.accessToken);
-    if (write.remote !== site.remote)
-      throw new Error('Repository credentials do not match the provisioned site.');
-    return {
-      status: 'ready',
-      projectType,
-      site,
-      write,
-      created: site.created,
-      credentials: authenticated,
-    };
-  }
-  throw new Error('The new anonymous site is already expired. Please retry later.');
-}
-
-export function agentSiteUrl(apiUrl: string, subdomain: string): string {
-  const domain =
-    new URL(apiUrl).hostname === 'leaves-dev.mintlify.com'
-      ? 'mint-dev.mintlify.me'
-      : 'mintlify.site';
-  return new URL(`https://${subdomain}.${domain}`).toString();
-}
-
-export function agentEditorUrl(site: Pick<AgentSite, 'subdomain' | 'orgSlug'>): string {
-  return site.orgSlug
-    ? new URL(`/${site.orgSlug}/${site.subdomain}/editor`, DASHBOARD_URL).toString()
-    : new URL(DASHBOARD_URL).toString();
-}
-
-export function formatDeployment(result: DeployResult, apiUrl: string): string {
-  if (result.status === 'claimed')
-    return 'This site has been claimed. Manage it in the Mintlify dashboard. Use mint deploy --new --subdomain <name> to create another site.';
-  const { site, write } = result;
-  const access = [
-    `Repository: ${site.remote}`,
-    `Branch: ${site.branch}`,
-    `Write token: ${write.token}`,
-    `Write token expires: ${write.tokenExpiresAt}`,
-  ];
-  if (result.projectType === 'workspace')
-    return [
-      result.created ? 'Base provisioned.' : 'Using the existing anonymous base.',
-      `Editor: ${agentEditorUrl(site)}`,
-      `Expires: ${site.expiresAt}. Claim it before then or it is deleted.`,
-    ].join('\n');
-  const siteUrl = agentSiteUrl(apiUrl, site.subdomain);
-  return [
-    result.created
-      ? 'Repository provisioned; push required to build the site.'
-      : 'Using the existing anonymous repository; push any changes to build the site.',
-    `Site: ${siteUrl}`,
-    `Expires: ${site.expiresAt}`,
-    ...access,
-    'Commit and push your documentation to this repository to start the build.',
-    'The site link becomes available after the push and build complete.',
-  ].join('\n');
-}

package/src/feedback.tsx

@@ -1,31 +0,0 @@
-import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
-
-import { API_URL } from './constants.js';
-
-export const FEEDBACK_CATEGORIES = ['bug', 'docs', 'idea'] as const;
-
-export type FeedbackInput = {
-  message: string;
-  clientId: string;
-  category: (typeof FEEDBACK_CATEGORIES)[number];
-};
-
-export async function sendFeedback(input: FeedbackInput): Promise<string | undefined> {
-  let res: Response;
-  try {
-    res = await fetch(`${API_URL}/api/cli/feedback`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ ...input, source: 'cli' }),
-    });
-  } catch {
-    return 'could not reach the server';
-  }
-  return res.ok ? undefined : `could not send feedback (HTTP ${res.status})`;
-}
-
-export async function feedback(input: FeedbackInput): Promise<boolean> {
-  const error = await sendFeedback(input);
-  addLog(error ? <ErrorLog message={error} /> : <SuccessLog message="feedback sent" />);
-  return !error;
-}

package/src/format.tsx

@@ -1,82 +0,0 @@
-import {
-  createMintIgnoreMatcher,
-  isMintIgnoredBy,
-  processMintIgnoreString,
-  type MintIgnoreMatcher,
-} from '@mintlify/common';
-import { getMintIgnore } from '@mintlify/prebuild';
-import { addLog, ErrorLog, SuccessLog } from '@mintlify/previewing';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-
-import { CMD_EXEC_PATH, terminate } from './helpers.js';
-
-async function getGitIgnore(): Promise<string[]> {
-  try {
-    const content = await fs.readFile(path.join(CMD_EXEC_PATH, '.gitignore'), 'utf-8');
-    return processMintIgnoreString(content);
-  } catch {
-    return [];
-  }
-}
-
-async function* walk(dir: string, matcher: MintIgnoreMatcher): AsyncGenerator<string> {
-  const entries = await fs.readdir(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const full = path.join(dir, entry.name);
-    const relative = path.relative(CMD_EXEC_PATH, full).split(path.sep).join('/');
-    if (isMintIgnoredBy(relative, matcher, entry.isDirectory())) continue;
-    if (entry.isDirectory()) {
-      yield* walk(full, matcher);
-    } else if (entry.name.endsWith('.mdx')) {
-      yield full;
-    }
-  }
-}
-
-export const formatHandler = async (): Promise<void> => {
-  const { mdxToPm, pmToMdx, canonicalPmToMdxOptions } = await import('./vendor/converter.js');
-  const ignores = [...(await getGitIgnore()), ...(await getMintIgnore(CMD_EXEC_PATH))];
-  const matcher = createMintIgnoreMatcher(ignores);
-  let total = 0;
-  let changed = 0;
-  let failed = 0;
-
-  for await (const file of walk(CMD_EXEC_PATH, matcher)) {
-    total++;
-    const relative = path.relative(CMD_EXEC_PATH, file);
-    try {
-      const raw = await fs.readFile(file, 'utf-8');
-      let formatted = raw;
-      let originalFrontmatterKeys = 0;
-      for (let pass = 0; pass < 3; pass++) {
-        const { doc, frontmatter } = mdxToPm(formatted);
-        if (pass === 0) originalFrontmatterKeys = Object.keys(frontmatter).length;
-        const next = `${pmToMdx(doc, { frontmatter, ...canonicalPmToMdxOptions })}\n`;
-        if (next === formatted) break;
-        formatted = next;
-      }
-      if (originalFrontmatterKeys > 0 && !formatted.startsWith('---')) {
-        throw new Error('formatting would remove frontmatter; file left untouched');
-      }
-      if (formatted !== raw) {
-        await fs.writeFile(file, formatted);
-        changed++;
-      }
-    } catch (error) {
-      failed++;
-      addLog(
-        <ErrorLog
-          message={`${relative}: ${error instanceof Error ? error.message : 'unknown error'}`}
-        />
-      );
-    }
-  }
-
-  addLog(
-    <SuccessLog
-      message={`formatted ${changed} of ${total} mdx file${total === 1 ? '' : 's'}${failed > 0 ? ` (${failed} failed)` : ''}`}
-    />
-  );
-  await terminate(failed > 0 ? 1 : 0);
-};

package/src/helpers.tsx

@@ -1,279 +0,0 @@
-import { getConfigPath } from '@mintlify/prebuild';
-import { MintConfigUpdater } from '@mintlify/prebuild';
-import {
-  addLog,
-  ErrorLog,
-  getClientVersion,
-  SuccessLog,
-  InfoLog,
-  SpinnerLog,
-  removeLastLog,
-  LOCAL_LINKED_CLI_VERSION,
-  WarningLog,
-} from '@mintlify/previewing';
-import { upgradeToDocsConfig, validatePathWithinCwd } from '@mintlify/validation';
-import detect from 'detect-port';
-import fse from 'fs-extra';
-import inquirer from 'inquirer';
-import yaml from 'js-yaml';
-import { execFile, execFileSync } from 'node:child_process';
-import { readFileSync } from 'node:fs';
-import fs from 'node:fs/promises';
-import { createRequire } from 'node:module';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import path from 'path';
-import type { ArgumentsCamelCase } from 'yargs';
-
-import { detectAgent } from './agent.js';
-import { shutdownPostHog } from './telemetry/client.js';
-
-export const CMD_EXEC_PATH = process.cwd();
-
-export const checkPort = async (argv: ArgumentsCamelCase): Promise<number | undefined> => {
-  const initialPort = typeof argv.port === 'number' ? argv.port : 3000;
-  if (initialPort === (await detect(initialPort))) return initialPort;
-
-  for (let port = initialPort + 1; port < initialPort + 10; port++) {
-    addLog(<InfoLog message={`port ${port - 1} is already in use. trying ${port} instead`} />);
-    if (port === (await detect(port))) return port;
-  }
-};
-
-export const checkNodeVersion = async () => {
-  let nodeVersionString = process.version;
-  if (nodeVersionString.charAt(0) === 'v') {
-    nodeVersionString = nodeVersionString.slice(1);
-  }
-  const versionArr = nodeVersionString.split('.');
-  const majorVersion = parseInt(versionArr[0]!, 10);
-  const minorVersion = parseInt(versionArr[1]!, 10);
-
-  if (majorVersion === 25) {
-    addLog(
-      <ErrorLog
-        message={`mintlify is not supported on node 25 (current version ${nodeVersionString}). Please switch to an LTS node version.`}
-      />
-    );
-    await terminate(1);
-  }
-
-  if (majorVersion < 20 || (majorVersion === 20 && minorVersion < 17)) {
-    addLog(
-      <ErrorLog message="mintlify requires node 20.17 or higher. Please upgrade to an LTS node version." />
-    );
-    await terminate(1);
-  }
-};
-
-export const checkForMintJson = async () => {
-  return !!(await getConfigPath(CMD_EXEC_PATH, 'mint'));
-};
-
-export const findDocsRoot = async (startDir: string): Promise<string> => {
-  const start = path.resolve(startDir);
-  const { root } = path.parse(start);
-
-  let dir = start;
-  while (dir !== root) {
-    if ((await getConfigPath(dir, 'docs')) || (await getConfigPath(dir, 'mint'))) return dir;
-    dir = path.dirname(dir);
-  }
-  return start;
-};
-
-export const checkForDocsJson = async () => {
-  const docsJsonPath = path.join(CMD_EXEC_PATH, 'docs.json');
-  if (!(await fse.pathExists(docsJsonPath))) {
-    addLog(<InfoLog message="new docs.json file is available" />);
-    const promptResult = await inquirer.prompt([
-      {
-        type: 'list',
-        name: 'action',
-        message: 'would you like to upgrade your mint.json to docs.json?',
-        choices: [
-          { name: 'upgrade (migrate from mint.json to docs.json)', value: 'upgrade' },
-          { name: 'continue (use existing mint.json)', value: 'continue' },
-        ],
-      },
-    ]);
-
-    const { action } = promptResult;
-
-    if (action === 'continue') {
-      addLog(<InfoLog message="proceeding with the existing mint.json..." />);
-    }
-
-    if (action === 'upgrade') {
-      addLog(<SpinnerLog message="upgrading docs.json..." />);
-      await upgradeConfig();
-    }
-  }
-};
-
-export const autoUpgradeIfNeeded = async () => {
-  const hasMintJson = await checkForMintJson();
-  if (!hasMintJson) return;
-
-  const docsJsonPath = path.join(CMD_EXEC_PATH, 'docs.json');
-  const hasDocsJson = await fse.pathExists(docsJsonPath);
-  if (!hasDocsJson) {
-    addLog(<WarningLog message="Legacy mint.json detected, auto-upgrading to docs.json" />);
-    addLog(<SpinnerLog message="upgrading mint.json to docs.json..." />);
-    await upgradeConfig();
-  }
-};
-
-export const upgradeConfig = async () => {
-  try {
-    const mintJsonPath = path.join(CMD_EXEC_PATH, 'mint.json');
-    const docsJsonPath = path.join(CMD_EXEC_PATH, 'docs.json');
-    const mintJsonFileContent = await fs.readFile(mintJsonPath, 'utf8');
-    const validationResult = await MintConfigUpdater.validateConfigJsonString(mintJsonFileContent);
-    const mintConfig = validationResult.data;
-    const upgradedDocsConfig = upgradeToDocsConfig(mintConfig, {
-      shouldUpgradeTheme: true,
-    });
-    await fs.writeFile(docsJsonPath, JSON.stringify(upgradedDocsConfig, null, 2));
-    removeLastLog();
-    addLog(<SuccessLog message="mint.json file has been upgraded to docs.json." />);
-  } catch (err) {
-    removeLastLog();
-    addLog(<ErrorLog message={err instanceof Error ? err.message : 'an unknown error occurred'} />);
-  }
-};
-
-const require = createRequire(import.meta.url);
-
-const isRunningFromLinkedBuild = (): boolean => {
-  try {
-    const thisFile = fileURLToPath(import.meta.url);
-    return !thisFile.split(path.sep).includes('node_modules');
-  } catch {
-    return false;
-  }
-};
-
-const readPackageVersion = (packageName: string): string | undefined => {
-  try {
-    const pkgPath = require.resolve(`${packageName}/package.json`);
-    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8')) as { version?: string };
-    return typeof pkg.version === 'string' ? pkg.version : undefined;
-  } catch {
-    return undefined;
-  }
-};
-
-export const getCliVersion = (
-  packageName: string = process.env.MINTLIFY_PACKAGE_NAME ?? 'mint'
-): string | undefined => {
-  if (process.env.CLI_TEST_MODE === 'true') {
-    return 'test-cli';
-  }
-  if (isRunningFromLinkedBuild()) {
-    return LOCAL_LINKED_CLI_VERSION;
-  }
-  return readPackageVersion(packageName);
-};
-
-export const getVersions = (
-  packageName: string = process.env.MINTLIFY_PACKAGE_NAME ?? 'mint'
-): {
-  cli: string | undefined;
-  client: string | undefined;
-} => {
-  const cli = getCliVersion(packageName);
-  const client = getClientVersion().trim();
-  return { cli, client };
-};
-
-// On Windows, npm/pnpm entrypoints are .cmd shims that Node refuses to spawn
-// without a shell (EINVAL since the CVE-2024-27980 fix). Everywhere else we
-// keep the shell disabled so arguments can't be interpreted as shell syntax.
-export const windowsCompatibleSpawnOptions = {
-  shell: process.platform === 'win32',
-};
-
-// npm package name grammar (optionally scoped). Rejecting anything else before
-// it reaches a package-manager spawn keeps the win32 shell path (above) safe
-// from shell metacharacters.
-const VALID_PACKAGE_NAME_PATTERN = /^(@[a-z0-9~-][a-z0-9._~-]*\/)?[a-z0-9~-][a-z0-9._~-]*$/;
-
-export const assertValidPackageName = (packageName: string): void => {
-  if (!VALID_PACKAGE_NAME_PATTERN.test(packageName)) {
-    throw new Error(`Invalid package name: ${packageName}`);
-  }
-};
-
-export const getLatestCliVersion = (packageName: string) => {
-  assertValidPackageName(packageName);
-  return execFileSync('npm', ['view', packageName, 'version', '--silent'], {
-    encoding: 'utf-8',
-    stdio: ['pipe', 'pipe', 'pipe'],
-    ...windowsCompatibleSpawnOptions,
-  }).trim();
-};
-
-export const suppressConsoleWarnings = (): void => {
-  // Ignore tailwind warnings and punycode deprecation warning
-  const ignoredMessages = [
-    'No utility classes were detected',
-    'https://tailwindcss.com/docs/content-configuration',
-    'DeprecationWarning',
-  ];
-  const originalConsoleError = console.error;
-  console.error = (...args) => {
-    const message = args.join(' ');
-    if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
-      return;
-    }
-    originalConsoleError.apply(console, args);
-  };
-  const originalConsoleWarn = console.warn;
-  console.warn = (...args) => {
-    const message = args.join(' ');
-    if (ignoredMessages.some((ignoredMessage) => message.includes(ignoredMessage))) {
-      return;
-    }
-    originalConsoleWarn.apply(console, args);
-  };
-};
-
-export const readLocalOpenApiFile = async (
-  filename: string
-): Promise<Record<string, unknown> | undefined> => {
-  const { resolvedPath } = validatePathWithinCwd(filename, CMD_EXEC_PATH);
-  const file = await fs.readFile(resolvedPath, 'utf-8');
-  const document = yaml.load(file) as Record<string, unknown> | undefined;
-  return document;
-};
-
-export const errorMessage = (error: unknown) =>
-  error instanceof Error ? error.message : String(error);
-
-export const terminate = async (code: number) => {
-  // Wait for the logs to be fully rendered before exiting
-  await new Promise((resolve) => setTimeout(resolve, 50));
-  await shutdownPostHog();
-  process.exit(code);
-};
-
-export const execFileAsync = promisify(execFile);
-
-export function isAI(): boolean {
-  return !process.stdin.isTTY || detectAgent() !== undefined;
-}
-
-export const detectPackageManager = async ({ packageName }: { packageName: string }) => {
-  assertValidPackageName(packageName);
-  try {
-    const { stdout: packagePath } = await execFileAsync('which', [packageName]);
-    if (packagePath.includes('pnpm')) {
-      return 'pnpm';
-    } else {
-      return 'npm';
-    }
-  } catch (error) {
-    return 'npm';
-  }
-};

package/src/idToken.ts

@@ -1,17 +0,0 @@
-interface IdTokenClaims {
-  email?: unknown;
-}
-
-export function getEmailFromIdToken(idToken: string | undefined): string | undefined {
-  if (!idToken) return undefined;
-
-  try {
-    const payload = idToken.split('.')[1];
-    if (!payload) return undefined;
-
-    const claims = JSON.parse(Buffer.from(payload, 'base64url').toString('utf8')) as IdTokenClaims;
-    return typeof claims.email === 'string' && claims.email.length > 0 ? claims.email : undefined;
-  } catch {
-    return undefined;
-  }
-}

package/src/index.ts

@@ -1,109 +0,0 @@
-#!/usr/bin/env node
-import { spawn, type ChildProcess } from 'child_process';
-import path from 'path';
-import { fileURLToPath } from 'url';
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-
-const packageName =
-  path.basename(process.argv[1] ?? '') === 'index.js'
-    ? 'mint'
-    : path.basename(process.argv[1] ?? '') || 'mint';
-
-let cli: ChildProcess | null = null;
-let isShuttingDown = false;
-let hasExited = false;
-
-const cleanup = async (): Promise<void> => {
-  if (isShuttingDown) return;
-  isShuttingDown = true;
-
-  if (cli && !cli.killed) {
-    try {
-      cli.kill('SIGTERM');
-
-      await new Promise<void>((resolve) => {
-        const timeout = setTimeout(() => {
-          if (cli && !cli.killed) {
-            cli.kill('SIGKILL');
-          }
-          resolve();
-        }, 5000);
-
-        cli!.once('exit', () => {
-          clearTimeout(timeout);
-          resolve();
-        });
-      });
-    } catch (error) {
-      // ignore
-    }
-  }
-};
-
-const exitProcess = (code: number) => {
-  if (hasExited) return;
-  hasExited = true;
-  process.exit(code);
-};
-
-const killSignals = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'SIGHUP'];
-killSignals.forEach((signal) => {
-  process.on(signal, async () => {
-    await cleanup();
-    exitProcess(0);
-  });
-});
-
-process.on('uncaughtException', async () => {
-  await cleanup();
-  exitProcess(1);
-});
-
-process.on('unhandledRejection', async () => {
-  await cleanup();
-  exitProcess(1);
-});
-
-// Arguments are passed as array elements to spawn() without shell: true,
-// so shell metacharacters are not interpreted and command injection is prevented.
-const userArgs = process.argv.slice(2);
-
-try {
-  cli = spawn('node', ['--no-deprecation', path.join(__dirname, '../bin/start.js'), ...userArgs], {
-    stdio: 'inherit',
-    env: {
-      ...process.env,
-      MINTLIFY_PACKAGE_NAME: packageName,
-      CLI_TEST_MODE: process.env.CLI_TEST_MODE ?? 'false',
-    },
-    windowsHide: process.platform === 'win32',
-    detached: false,
-  });
-
-  cli.on('error', async (error) => {
-    console.error(`Failed to start ${packageName}: ${error.message}`);
-    await cleanup();
-    exitProcess(1);
-  });
-
-  cli.on('exit', (code) => {
-    exitProcess(code ?? 0);
-  });
-} catch (error) {
-  console.error(`Failed to start ${packageName}: ${error}`);
-  exitProcess(1);
-}
-
-process.on('exit', () => {
-  if (cli && !cli.killed) {
-    try {
-      cli.kill('SIGKILL');
-    } catch (error) {
-      // ignore
-    }
-  }
-});
-
-export { cli };