@mintlify/cli 4.0.1813 → 4.1.1

package/bin/agent-credentials.js

@@ -1,124 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-import { createHash } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { z } from 'zod';
-import { CONFIG_DIR } from './constants.js';
-import { getKeytar } from './keyring.js';
-const service = 'mintlify-agent';
-const fallbackFile = () => path.join(CONFIG_DIR, 'agent-credentials.json');
-export const agentCredentialsSchema = z.object({
-    registrationId: z.string().min(1),
-    issuer: z.url(),
-    assertion: z.string().min(1),
-    claimToken: z.string().min(1),
-    claimVerified: z.boolean().optional(),
-    accessToken: z.string().min(1).optional(),
-    accessTokenExpiresAt: z.number().optional(),
-});
-function projectAccount(apiUrl, directory) {
-    return `project:${createHash('sha256')
-        .update(JSON.stringify([new URL(apiUrl).origin, path.resolve(directory)]))
-        .digest('hex')}`;
-}
-function registrationAccount(apiUrl, registrationId) {
-    return `${new URL(apiUrl).origin}:${registrationId}`;
-}
-function readFallback() {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return z
-                .record(z.string(), z.string())
-                .parse(JSON.parse(yield fs.readFile(fallbackFile(), 'utf-8')));
-        }
-        catch (_a) {
-            return {};
-        }
-    });
-}
-function writeFallback(entries) {
-    return __awaiter(this, void 0, void 0, function* () {
-        yield fs.mkdir(CONFIG_DIR, { recursive: true });
-        const temp = `${fallbackFile()}.${process.pid}.tmp`;
-        yield fs.writeFile(temp, JSON.stringify(entries, null, 2), { mode: 0o600 });
-        yield fs.chmod(temp, 0o600);
-        yield fs.rename(temp, fallbackFile());
-    });
-}
-function getSecret(account) {
-    return __awaiter(this, void 0, void 0, function* () {
-        let keyringError;
-        try {
-            const value = yield (yield getKeytar()).getPassword(service, account);
-            if (value)
-                return value;
-        }
-        catch (error) {
-            keyringError = error;
-        }
-        const value = (yield readFallback())[account];
-        if (value)
-            return value;
-        if (keyringError)
-            throw keyringError;
-        return null;
-    });
-}
-function setSecret(account, value) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            yield (yield getKeytar()).setPassword(service, account, value);
-        }
-        catch (_a) {
-            yield writeFallback(Object.assign(Object.assign({}, (yield readFallback())), { [account]: value }));
-            yield getKeytar()
-                .then((keytar) => keytar.deletePassword(service, account))
-                .catch(() => { });
-            return;
-        }
-        const _b = yield readFallback(), _c = account, stale = _b[_c], rest = __rest(_b, [typeof _c === "symbol" ? _c : _c + ""]);
-        if (stale)
-            yield writeFallback(rest).catch(() => { });
-    });
-}
-export function loadAgentCredentials(apiUrl, directory) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const registrationId = yield getSecret(projectAccount(apiUrl, directory));
-        if (!registrationId)
-            return null;
-        const value = yield getSecret(registrationAccount(apiUrl, registrationId));
-        if (!value)
-            throw new Error('Saved agent credentials are missing. Use --new to create another site.');
-        const credentials = agentCredentialsSchema.parse(JSON.parse(value));
-        if (credentials.registrationId !== registrationId) {
-            throw new Error('Saved agent credentials do not match this project.');
-        }
-        return credentials;
-    });
-}
-export function saveAgentCredentials(apiUrl, directory, credentials) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const value = agentCredentialsSchema.parse(credentials);
-        yield setSecret(registrationAccount(apiUrl, value.registrationId), JSON.stringify(value));
-        yield setSecret(projectAccount(apiUrl, directory), value.registrationId);
-    });
-}

package/bin/agent-deployment.js

@@ -1,96 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { setTimeout } from 'node:timers/promises';
-import { z } from 'zod';
-import { agentRequest, agentResponse } from './agent-http.js';
-const readySchema = z.object({
-    status: z.literal('ready'),
-    deploymentId: z.string().min(1),
-    subdomain: z.string().min(1),
-    remote: z.url(),
-    branch: z.literal('main'),
-    expiresAt: z.iso.datetime(),
-    orgSlug: z.string().min(1).optional(),
-});
-const existingSchema = z.discriminatedUnion('status', [
-    readySchema.extend({ code: z.literal('deployment_already_exists') }),
-    z.object({
-        status: z.literal('provisioning'),
-        code: z.literal('deployment_already_exists'),
-        deploymentId: z.string().optional(),
-        subdomain: z.string().optional(),
-    }),
-    z.object({
-        status: z.literal('expired'),
-        code: z.enum(['deployment_already_exists', 'deployment_claim_expired']),
-        deploymentId: z.string(),
-        subdomain: z.string(),
-        expiresAt: z.iso.datetime().optional(),
-    }),
-]);
-const writeTokenSchema = z.object({
-    remote: z.url(),
-    branch: z.literal('main'),
-    token: z.string().min(1),
-    tokenExpiresAt: z.iso.datetime(),
-});
-const trustedReposSchema = z.object({
-    subdomain: z.string().min(1),
-    trustedRepos: z.array(z.object({ repositoryId: z.string(), repository: z.string(), branch: z.string() })),
-});
-export function provisionAgentSite(apiUrl, accessToken, settings) {
-    return __awaiter(this, void 0, void 0, function* () {
-        for (let attempt = 0; attempt < 4; attempt++) {
-            const response = yield agentRequest(`${apiUrl}/api/agent/deployments/provision`, {
-                method: 'POST',
-                headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
-                body: JSON.stringify(Object.assign(Object.assign({}, settings), { docsPath: '' })),
-            });
-            if (response.status !== 409) {
-                return Object.assign(Object.assign({}, (yield agentResponse(response, readySchema))), { created: true });
-            }
-            const body = yield response.json().catch(() => null);
-            const parsed = existingSchema.safeParse(body);
-            if (!parsed.success)
-                throw new Error('The deployment service returned an unexpected response.');
-            if (parsed.data.status !== 'provisioning')
-                return Object.assign(Object.assign({}, parsed.data), { created: false });
-            if (attempt < 3)
-                yield setTimeout(1000 * (attempt + 1));
-        }
-        throw new Error('Your site is still provisioning. Run the same command again.');
-    });
-}
-export function getAgentWriteToken(apiUrl, accessToken) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return agentResponse(yield agentRequest(`${apiUrl}/api/agent/deployments/token`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${accessToken}` },
-        }), writeTokenSchema);
-    });
-}
-export function getGithubActionsWriteToken(apiUrl, oidcToken, subdomain) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return agentResponse(yield agentRequest(`${apiUrl}/api/agent/deployments/github-actions/token`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${oidcToken}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify({ subdomain }),
-        }), writeTokenSchema);
-    });
-}
-export function trustGithubRepo(apiUrl, accessToken, repo) {
-    return __awaiter(this, void 0, void 0, function* () {
-        return agentResponse(yield agentRequest(`${apiUrl}/api/agent/deployments/trusted-repos`, {
-            method: 'POST',
-            headers: { Authorization: `Bearer ${accessToken}`, 'Content-Type': 'application/json' },
-            body: JSON.stringify(repo),
-        }), trustedReposSchema);
-    });
-}

package/bin/agent-http.js

@@ -1,45 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { z } from 'zod';
-const errorSchema = z.object({ code: z.string().optional(), error: z.string().optional() });
-export class AgentApiError extends Error {
-    constructor(status, code) {
-        super(`Agent request failed (HTTP ${status}).${code ? ` Code: ${code}.` : ''}`);
-        this.status = status;
-        this.code = code;
-    }
-}
-export function agentRequest(url, init) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            const timeout = AbortSignal.timeout(30000);
-            const signal = (init === null || init === void 0 ? void 0 : init.signal) ? AbortSignal.any([init.signal, timeout]) : timeout;
-            return yield fetch(url, Object.assign(Object.assign({}, init), { redirect: 'error', signal }));
-        }
-        catch (_a) {
-            throw new Error('Could not reach the agent service. Retry the same command.');
-        }
-    });
-}
-export function agentResponse(response, schema) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a, _b;
-        const body = yield response.json().catch(() => null);
-        if (!response.ok) {
-            const error = errorSchema.safeParse(body);
-            const code = error.success ? ((_a = error.data.code) !== null && _a !== void 0 ? _a : error.data.error) : undefined;
-            throw new AgentApiError(response.status, (_b = code === null || code === void 0 ? void 0 : code.match(/^[a-z_]{1,80}$/)) === null || _b === void 0 ? void 0 : _b[0]);
-        }
-        const parsed = schema.safeParse(body);
-        if (!parsed.success)
-            throw new Error('The agent service returned an unexpected response.');
-        return parsed.data;
-    });
-}

package/bin/agent-setup-config.js

@@ -1,141 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { applyEdits, modify, parse } from 'jsonc-parser';
-import { randomUUID } from 'node:crypto';
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import { parse as parseToml } from 'smol-toml';
-export const ADMIN_MCP_NAME = 'mintlify-admin';
-export const ADMIN_MCP_URL = 'https://mcp.mintlify.com';
-function isRecord(value) {
-    return typeof value === 'object' && value !== null && !Array.isArray(value);
-}
-function readConfig(file) {
-    return __awaiter(this, void 0, void 0, function* () {
-        try {
-            return yield fs.readFile(file, 'utf8');
-        }
-        catch (error) {
-            if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
-                return undefined;
-            throw error;
-        }
-    });
-}
-function configPath(agent, options) {
-    var _a;
-    const env = (_a = options.env) !== null && _a !== void 0 ? _a : process.env;
-    if (agent === 'codex') {
-        let directory = path.join(options.cwd, '.codex');
-        if (options.global)
-            directory = env.CODEX_HOME || path.join(options.homeDir, '.codex');
-        return path.join(directory, 'config.toml');
-    }
-    if (agent === 'cursor') {
-        const directory = options.global ? options.homeDir : options.cwd;
-        return path.join(directory, '.cursor', 'mcp.json');
-    }
-    if (options.global) {
-        if (env.CLAUDE_CONFIG_DIR) {
-            throw new Error('CLAUDE_CONFIG_DIR is set. Configure Claude Code with: claude mcp add --scope user --transport http mintlify-admin https://mcp.mintlify.com');
-        }
-        return path.join(options.homeDir, '.claude.json');
-    }
-    return path.join(options.cwd, '.mcp.json');
-}
-export function prepareMcpConfig(agent, options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        const requestedPath = configPath(agent, options);
-        const file = yield fs.realpath(requestedPath).catch((error) => {
-            if (error instanceof Error && 'code' in error && error.code === 'ENOENT')
-                return requestedPath;
-            throw error;
-        });
-        const original = yield readConfig(file);
-        const source = original !== null && original !== void 0 ? original : '';
-        const key = agent === 'codex' ? 'mcp_servers' : 'mcpServers';
-        let config;
-        try {
-            if (agent === 'codex') {
-                config = parseToml(source);
-            }
-            else {
-                const errors = [];
-                config = parse(source || '{}', errors, { allowTrailingComma: true });
-                if (errors.length > 0)
-                    throw new Error('Invalid JSON');
-            }
-        }
-        catch (_a) {
-            throw new Error(`Cannot parse ${file}. Fix its configuration before running setup.`);
-        }
-        if (!isRecord(config))
-            throw new Error(`Expected an object in ${file}.`);
-        const servers = config[key];
-        if (servers !== undefined && !isRecord(servers)) {
-            throw new Error(`Expected ${key} to be an object in ${file}.`);
-        }
-        const existing = servers === null || servers === void 0 ? void 0 : servers[ADMIN_MCP_NAME];
-        if (existing !== undefined) {
-            if (!isRecord(existing) || existing.url !== ADMIN_MCP_URL || existing.command !== undefined) {
-                throw new Error(`${ADMIN_MCP_NAME} already has a different configuration in ${file}. Rename or remove that entry before running setup.`);
-            }
-            if (agent === 'claude-code' && existing.type !== 'http') {
-                throw new Error(`Set type to "http" for ${ADMIN_MCP_NAME} in ${file} before running setup.`);
-            }
-            return { path: file, original, contents: undefined };
-        }
-        const newline = source.includes('\r\n') ? '\r\n' : '\n';
-        let contents;
-        if (agent === 'codex') {
-            contents = `${source}${newline}[mcp_servers.${ADMIN_MCP_NAME}]${newline}url = "${ADMIN_MCP_URL}"${newline}`;
-            try {
-                parseToml(contents);
-            }
-            catch (_b) {
-                throw new Error(`Cannot safely extend ${file}. Add a ${ADMIN_MCP_NAME} entry with url = "${ADMIN_MCP_URL}" to mcp_servers manually.`);
-            }
-        }
-        else {
-            const server = { url: ADMIN_MCP_URL };
-            if (agent === 'claude-code')
-                server.type = 'http';
-            contents = applyEdits(source || '{}', modify(source || '{}', [key, ADMIN_MCP_NAME], server, {
-                formattingOptions: { insertSpaces: true, tabSize: 2, eol: newline },
-            }));
-            if (!contents.endsWith(newline))
-                contents += newline;
-        }
-        return { path: file, original, contents };
-    });
-}
-export function writeMcpConfig(plan) {
-    return __awaiter(this, void 0, void 0, function* () {
-        if ((yield readConfig(plan.path)) !== plan.original) {
-            throw new Error(`${plan.path} changed during setup. Run setup again to preserve those changes.`);
-        }
-        if (plan.contents === undefined)
-            return;
-        yield fs.mkdir(path.dirname(plan.path), { recursive: true, mode: 0o700 });
-        let mode = 0o600;
-        if (plan.original !== undefined)
-            mode = (yield fs.stat(plan.path)).mode;
-        const temporaryPath = `${plan.path}.${randomUUID()}.tmp`;
-        try {
-            yield fs.writeFile(temporaryPath, plan.contents, { mode, flag: 'wx' });
-            if (plan.original !== undefined)
-                yield fs.chmod(temporaryPath, mode);
-            yield fs.rename(temporaryPath, plan.path);
-        }
-        finally {
-            yield fs.rm(temporaryPath, { force: true });
-        }
-    });
-}

package/bin/agent-setup.js

@@ -1,146 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { checkbox } from '@inquirer/prompts';
-import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { stripVTControlCharacters } from 'node:util';
-import { ADMIN_MCP_NAME, ADMIN_MCP_URL, prepareMcpConfig, writeMcpConfig, } from './agent-setup-config.js';
-import { detectAgent } from './agent.js';
-export const SETUP_AGENTS = ['claude-code', 'codex', 'cursor'];
-const AGENT_LABELS = {
-    'claude-code': 'Claude Code',
-    codex: 'Codex',
-    cursor: 'Cursor',
-};
-function isSetupAgent(value) {
-    return SETUP_AGENTS.some((agent) => agent === value);
-}
-function detectedAgents() {
-    const homeDir = os.homedir();
-    const current = detectAgent();
-    return SETUP_AGENTS.filter((agent) => {
-        if (agent === 'codex') {
-            return (current === 'codex_cli' ||
-                existsSync(process.env.CODEX_HOME || path.join(homeDir, '.codex')));
-        }
-        if (agent === 'claude-code') {
-            return (current === 'claude_code' ||
-                existsSync(process.env.CLAUDE_CONFIG_DIR || path.join(homeDir, '.claude')));
-        }
-        return (current === 'cursor' || current === 'cursor-cli' || existsSync(path.join(homeDir, '.cursor')));
-    });
-}
-export function installSkills(agents, global) {
-    const args = [
-        '--yes',
-        'skills@1.7.4',
-        'add',
-        'https://mintlify.com/docs',
-        '--agent',
-        ...agents,
-        '--yes',
-    ];
-    if (global)
-        args.push('--global');
-    return new Promise((resolve, reject) => {
-        const child = spawn('npx', args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
-            shell: process.platform === 'win32',
-        });
-        let output = '';
-        const recordOutput = (chunk) => {
-            output = (output + chunk.toString()).slice(-65536);
-        };
-        child.stdout.on('data', (chunk) => {
-            recordOutput(chunk);
-            process.stdout.write(chunk.toString());
-        });
-        child.stderr.on('data', (chunk) => {
-            recordOutput(chunk);
-            process.stderr.write(chunk.toString());
-        });
-        child.on('error', () => reject(new Error('Could not run npx. Install npm and run setup again.')));
-        child.on('close', (code, signal) => {
-            if (code !== 0 || /Failed to install\s+\d+/.test(stripVTControlCharacters(output))) {
-                reject(new Error(`Skills installation failed (${signal !== null && signal !== void 0 ? signal : code}). Review the installer output and run setup again.`));
-            }
-            else {
-                resolve();
-            }
-        });
-    });
-}
-export function setupAgent(options) {
-    return __awaiter(this, void 0, void 0, function* () {
-        var _a;
-        const [major = 0, minor = 0] = process.versions.node.split('.').map(Number);
-        if (major < 22 || (major === 22 && minor < 20)) {
-            throw new Error('mint agent setup requires Node.js 22.20 or later to install skills. Upgrade Node.js and try again.');
-        }
-        const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-        let agents = [];
-        for (const agent of (_a = options.agents) !== null && _a !== void 0 ? _a : []) {
-            if (!isSetupAgent(agent))
-                throw new Error(`Unsupported agent: ${agent}`);
-            if (!agents.includes(agent))
-                agents.push(agent);
-        }
-        if (agents.length === 0) {
-            const detected = detectedAgents();
-            if (!interactive) {
-                agents = detected;
-            }
-            else {
-                agents = yield checkbox({
-                    message: 'Which agents should use Mintlify?',
-                    choices: SETUP_AGENTS.map((agent) => ({
-                        name: AGENT_LABELS[agent],
-                        value: agent,
-                        checked: detected.includes(agent),
-                    })),
-                    required: true,
-                });
-            }
-        }
-        if (agents.length === 0) {
-            throw new Error('No supported agents detected. Pass --agent claude-code, codex, or cursor.');
-        }
-        const location = { cwd: process.cwd(), homeDir: os.homedir(), global: options.global };
-        const plans = yield Promise.all(agents.map((agent) => prepareMcpConfig(agent, location)));
-        const scope = options.global ? 'your user account' : 'this project';
-        process.stdout.write(`Setting up Mintlify skills and Admin MCP for ${scope}.\n`);
-        yield installSkills(agents, options.global);
-        for (const plan of plans) {
-            yield writeMcpConfig(plan);
-            const action = plan.contents === undefined ? 'Already configured' : 'Configured';
-            process.stdout.write(`${action}: ${plan.path}\n`);
-        }
-        process.stdout.write('\nAdmin MCP is configured. Complete OAuth sign-in to grant account and project access:\n');
-        for (const agent of agents) {
-            if (agent === 'codex') {
-                let command = `codex mcp login ${ADMIN_MCP_NAME}`;
-                if (!options.global) {
-                    const config = `mcp_servers.${ADMIN_MCP_NAME}.url='${ADMIN_MCP_URL}'`;
-                    command = `codex -c "${config}" mcp login ${ADMIN_MCP_NAME}`;
-                }
-                process.stdout.write(`  Codex: run ${command}. Trust the project before using its MCP configuration.\n`);
-            }
-            else if (agent === 'claude-code') {
-                process.stdout.write(`  Claude Code: open /mcp and authenticate ${ADMIN_MCP_NAME}. Approve the project server if prompted.\n`);
-            }
-            else {
-                process.stdout.write(`  Cursor: open MCP settings and connect ${ADMIN_MCP_NAME}.\n`);
-            }
-        }
-        process.stdout.write('Setup: https://mintlify.com/docs/ai/mintlify-mcp\n');
-    });
-}

package/bin/agent.js

@@ -1,42 +0,0 @@
-import { existsSync } from 'node:fs';
-const set = (...names) => (env) => names.some((name) => Boolean(env[name]));
-const matches = (name, pattern) => (env) => { var _a; return pattern.test((_a = env[name]) !== null && _a !== void 0 ? _a : ''); };
-const noTTY = (check) => (env) => !process.stdout.isTTY && check(env);
-const AGENTS = [
-    [
-        'cursor-cli',
-        (env) => set('CURSOR_AGENT')(env) || env.CURSOR_EXTENSION_HOST_ROLE === 'agent-exec',
-    ],
-    ['kimi', set('KIMI_PLUGIN_ROOT')],
-    ['grok', set('GROK_PLUGIN_ROOT', 'GROK_PLUGIN_DATA')],
-    ['gemini_cli', set('GEMINI_CLI')],
-    ['cline', set('CLINE_ACTIVE')],
-    [
-        'codex_cli',
-        set('CODEX_SANDBOX', 'CODEX_CI', 'CODEX_THREAD_ID', 'CODEX_SANDBOX_NETWORK_DISABLED'),
-    ],
-    ['antigravity', set('ANTIGRAVITY_AGENT', 'ANTIGRAVITY_CLI_ALIAS')],
-    ['augment-cli', set('AUGMENT_AGENT')],
-    ['open_code', (env) => set('OPENCODE')(env) || noTTY(set('OPENCODE_CLIENT'))(env)],
-    ['goose', noTTY(set('GOOSE_PROVIDER'))],
-    ['junie', set('JUNIE_DATA', 'JUNIE_SHIM_PATH')],
-    ['pi', matches('PATH', /\.pi[\\/]agent/)],
-    ['cowork', (env) => set('CLAUDE_CODE_IS_COWORK')(env) && set('CLAUDECODE', 'CLAUDE_CODE')(env)],
-    ['claude_code', (env) => set('CLAUDECODE', 'CLAUDE_CODE')(env) || env.TERM_PROGRAM === 'claude'],
-    ['github-copilot', noTTY(set('COPILOT_MODEL', 'COPILOT_ALLOW_ALL'))],
-    ['openclaw', set('OPENCLAW_SHELL')],
-    ['devin', (env) => matches('EDITOR', /devin/)(env) || existsSync('/opt/.devin')],
-    ['replit', noTTY(set('REPL_ID'))],
-    ['kiro', noTTY(matches('TERM_PROGRAM', /kiro/))],
-    ['cursor', noTTY(set('CURSOR_TRACE_ID'))],
-];
-export function detectAgent(env = process.env) {
-    var _a, _b;
-    const explicit = (_a = (env.AI_AGENT || env.AGENT)) === null || _a === void 0 ? void 0 : _a.trim();
-    if (explicit)
-        return explicit.toLowerCase();
-    return (_b = AGENTS.find(([, check]) => check(env))) === null || _b === void 0 ? void 0 : _b[0];
-}
-export function isCI(env = process.env) {
-    return Boolean(env.CI && env.CI !== 'false' && env.CI !== '0');
-}

package/bin/analytics/client.js

@@ -1,60 +0,0 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { authenticatedFetch } from '../authenticatedFetch.js';
-import { API_URL } from '../constants.js';
-function request(path_1) {
-    return __awaiter(this, arguments, void 0, function* (path, params = {}) {
-        const url = new URL(`${API_URL}/api/cli/analytics${path}`);
-        for (const [key, value] of Object.entries(params)) {
-            if (value !== undefined)
-                url.searchParams.set(key, String(value));
-        }
-        const res = yield authenticatedFetch(url.toString(), {
-            headers: { Accept: 'application/json' },
-        });
-        if (!res.ok) {
-            const body = yield res.text().catch(() => '');
-            throw new Error(`API error (${res.status}): ${body || res.statusText}`);
-        }
-        return res.json();
-    });
-}
-export function getKpi(opts, subdomain) {
-    return request('/kpi', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getFeedback(opts, subdomain) {
-    return request('/feedback', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getFeedbackByPage(opts, subdomain) {
-    return request('/feedback/by-page', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getConversations(opts, subdomain) {
-    return request('/assistant', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getAssistantThread(threadId, subdomain) {
-    return request(`/assistant/threads/${encodeURIComponent(threadId)}`, {
-        subdomain,
-    });
-}
-export function getSearches(opts, subdomain) {
-    return request('/searches', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getViews(opts, subdomain) {
-    return request('/views', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getVisitors(opts, subdomain) {
-    return request('/visitors', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getBuckets(opts, subdomain) {
-    return request('/conversations/buckets', Object.assign(Object.assign({}, opts), { subdomain }));
-}
-export function getBucketThreads(bucketId, opts, subdomain) {
-    return request(`/conversations/buckets/${encodeURIComponent(bucketId)}`, Object.assign(Object.assign({}, opts), { subdomain }));
-}

package/bin/analytics/dates.js

@@ -1,6 +0,0 @@
-export function formatLocalDate(date) {
-    const year = date.getFullYear();
-    const month = String(date.getMonth() + 1).padStart(2, '0');
-    const day = String(date.getDate()).padStart(2, '0');
-    return `${year}-${month}-${day}`;
-}