mcpmake 0.1.0

package/dist/commands/publish.d.ts

@@ -0,0 +1,27 @@
+declare const _default: import("citty").CommandDef<{
+    directory: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    registry: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'remote-url': {
+        type: "string";
+        description: string;
+    };
+    push: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/publish.js

@@ -0,0 +1,334 @@
+import { defineCommand } from 'citty';
+import { readFile, writeFile, readdir } from 'node:fs/promises';
+import { resolve, join } from 'node:path';
+import { execFile as execFileCb } from 'node:child_process';
+import { promisify } from 'node:util';
+import { stringify as yamlStringify } from 'yaml';
+import { logger } from '../utils/logger.js';
+import { fail } from '../utils/fail.js';
+import { pathExists } from '../utils/fs.js';
+import { buildServerJson, deriveServerName, parseEnvExample, validateServerName, OFFICIAL_REGISTRY_URL, } from '../registry/official-registry.js';
+const execFile = promisify(execFileCb);
+export default defineCommand({
+    meta: {
+        name: 'publish',
+        description: 'Generate registry manifests (Smithery/Glama) or publish to the official MCP Registry',
+    },
+    args: {
+        directory: {
+            type: 'positional',
+            description: 'Path to the generated MCP server project',
+            required: true,
+        },
+        registry: {
+            type: 'string',
+            alias: 'r',
+            description: 'Target registry: official, smithery, glama (default: smithery + glama)',
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'official: registry name (e.g. io.github.you/my-server); default derived from the git remote',
+        },
+        'remote-url': {
+            type: 'string',
+            description: 'official: hosted endpoint URL to advertise as a remote (streamable-http)',
+        },
+        push: {
+            type: 'boolean',
+            description: 'official: run `mcp-publisher publish` after generating server.json (requires login + npm publish first)',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        const projectDir = resolve(args.directory);
+        const pkgPath = resolve(projectDir, 'package.json');
+        if (!(await pathExists(pkgPath))) {
+            await fail(`Not a valid project directory (no package.json): ${projectDir}`);
+        }
+        const registry = args.registry?.toLowerCase();
+        if (registry && !['official', 'smithery', 'glama'].includes(registry)) {
+            await fail('Invalid registry. Use "official", "smithery", "glama", or omit for both.');
+        }
+        // Read project metadata
+        const pkgJson = JSON.parse(await readFile(pkgPath, 'utf-8'));
+        // The official MCP Registry has a distinct flow (server.json + mcp-publisher).
+        if (registry === 'official') {
+            await publishOfficial(projectDir, pkgPath, pkgJson, {
+                name: args.name,
+                remoteUrl: args['remote-url'],
+                push: args.push ?? false,
+            });
+            return;
+        }
+        const name = pkgJson.name ?? 'mcp-server';
+        const version = pkgJson.version ?? '1.0.0';
+        const description = pkgJson.description ?? '';
+        // Detect transport mode from the project's main entry
+        const transport = await detectTransport(projectDir);
+        // Extract tool list
+        const tools = await extractTools(projectDir);
+        if (tools.length === 0) {
+            logger.warn('No tools found in the project. The manifest will have an empty tool list.');
+        }
+        else {
+            logger.info(`Found ${tools.length} tool(s)`);
+        }
+        const manifest = { name, version, description, transport, tools };
+        const generateSmithery = !registry || registry === 'smithery';
+        const generateGlama = !registry || registry === 'glama';
+        if (generateSmithery) {
+            await writeSmitheryManifest(projectDir, manifest);
+        }
+        if (generateGlama) {
+            await writeGlamaManifest(projectDir, manifest);
+        }
+        // Print next steps
+        logger.info('');
+        logger.success('Next steps:');
+        logger.info('  1. Review the generated manifest file(s)');
+        logger.info('  2. Commit and push to your GitHub repository');
+        if (generateSmithery) {
+            logger.info('  3. Register your server at https://smithery.ai — Smithery discovers');
+            logger.info('     servers from GitHub repos containing a smithery.yaml file');
+        }
+        if (generateGlama) {
+            logger.info(`  ${generateSmithery ? '4' : '3'}. Submit your server at https://glama.ai/mcp/servers — Glama discovers`);
+            logger.info('     servers from GitHub repos containing a glama.json file');
+        }
+    },
+});
+/**
+ * Detect whether the project uses stdio or HTTP transport by inspecting
+ * the main server entry file.
+ */
+async function detectTransport(projectDir) {
+    const stdioEntry = resolve(projectDir, 'src/index.ts');
+    const httpEntry = resolve(projectDir, 'src/index.ts');
+    for (const entry of [stdioEntry, httpEntry]) {
+        if (await pathExists(entry)) {
+            try {
+                const content = await readFile(entry, 'utf-8');
+                if (content.includes('SSEServerTransport') ||
+                    content.includes('StreamableHTTPServerTransport')) {
+                    return 'http';
+                }
+            }
+            catch {
+                // ignore read errors
+            }
+        }
+    }
+    return 'stdio';
+}
+/**
+ * Extract tool names and descriptions from the generated project.
+ * Tries multiple sources in priority order:
+ *   1. tool-catalog.json (dynamic discovery mode)
+ *   2. Individual tool handler files in src/tools/
+ */
+async function extractTools(projectDir) {
+    // Strategy 1: tool-catalog.json (dynamic discovery projects)
+    const catalogPath = resolve(projectDir, 'src/tool-catalog.json');
+    if (await pathExists(catalogPath)) {
+        try {
+            const catalog = JSON.parse(await readFile(catalogPath, 'utf-8'));
+            if (Array.isArray(catalog)) {
+                return catalog.map((entry) => ({
+                    name: entry.name,
+                    description: entry.description ?? entry.title ?? '',
+                }));
+            }
+        }
+        catch {
+            logger.warn('Failed to parse tool-catalog.json, falling back to tool file scanning');
+        }
+    }
+    // Strategy 2: Parse individual tool handler files in src/tools/
+    const toolsDir = resolve(projectDir, 'src/tools');
+    if (!(await pathExists(toolsDir))) {
+        return [];
+    }
+    const tools = [];
+    let entries;
+    try {
+        entries = await readdir(toolsDir);
+    }
+    catch {
+        return [];
+    }
+    for (const file of entries) {
+        if (file === 'index.ts' || !file.endsWith('.ts'))
+            continue;
+        try {
+            const content = await readFile(join(toolsDir, file), 'utf-8');
+            // Extract the tool name from server.registerTool('name', ...)
+            const nameMatch = content.match(/registerTool\(\s*['"]([^'"]+)['"]/);
+            if (!nameMatch)
+                continue;
+            const toolName = nameMatch[1];
+            // Extract the description from description: `...` or description: '...'
+            const descMatch = content.match(/description:\s*[`'"]([^`'"]*)[`'"]/);
+            const toolDescription = descMatch ? descMatch[1] : '';
+            tools.push({ name: toolName, description: toolDescription });
+        }
+        catch {
+            // skip files that can't be read
+        }
+    }
+    return tools;
+}
+async function writeSmitheryManifest(projectDir, manifest) {
+    const smitheryData = {
+        name: manifest.name,
+        description: manifest.description,
+        version: manifest.version,
+        transport: manifest.transport,
+        tools: manifest.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+        })),
+    };
+    const yamlContent = yamlStringify(smitheryData, { lineWidth: 120 });
+    const outputPath = resolve(projectDir, 'smithery.yaml');
+    await writeFile(outputPath, yamlContent, 'utf-8');
+    logger.success(`Generated ${outputPath}`);
+}
+async function writeGlamaManifest(projectDir, manifest) {
+    const glamaData = {
+        name: manifest.name,
+        version: manifest.version,
+        description: manifest.description,
+        transport: manifest.transport,
+        tools: manifest.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+        })),
+    };
+    const jsonContent = JSON.stringify(glamaData, null, 2) + '\n';
+    const outputPath = resolve(projectDir, 'glama.json');
+    await writeFile(outputPath, jsonContent, 'utf-8');
+    logger.success(`Generated ${outputPath}`);
+}
+/**
+ * Generate a schema-conformant `server.json`, set the npm `mcpName` validation
+ * marker, and either print the publish steps or (with --push) run the official
+ * `mcp-publisher` CLI. mcpmake never re-implements the registry auth flow.
+ */
+async function publishOfficial(projectDir, pkgPath, pkgJson, opts) {
+    const packageName = typeof pkgJson.name === 'string' ? pkgJson.name : undefined;
+    if (!packageName) {
+        return await fail('package.json has no "name" — set it before publishing to the official registry.');
+    }
+    const version = typeof pkgJson.version === 'string' ? pkgJson.version : '1.0.0';
+    const description = typeof pkgJson.description === 'string' ? pkgJson.description : undefined;
+    // Repository URL: package.json `repository`, else the git `origin` remote.
+    const repositoryUrl = extractRepoUrl(pkgJson.repository) ?? (await gitRemoteUrl(projectDir));
+    const name = deriveServerName({ explicit: opts.name, repositoryUrl });
+    if (!name) {
+        logger.info('Pass --name (e.g. --name io.github.you/my-server) or add a GitHub "repository" to package.json.');
+        return await fail('Could not determine the registry name.');
+    }
+    const nameError = validateServerName(name);
+    if (nameError) {
+        return await fail(nameError);
+    }
+    // Environment variables from .env.example feed the server.json env spec.
+    let envVars = [];
+    const envPath = resolve(projectDir, '.env.example');
+    if (await pathExists(envPath)) {
+        envVars = parseEnvExample(await readFile(envPath, 'utf-8'));
+    }
+    const serverJson = buildServerJson({
+        name,
+        description,
+        version,
+        repositoryUrl,
+        packageIdentifier: packageName,
+        packageVersion: version,
+        environmentVariables: envVars,
+        remoteUrl: opts.remoteUrl,
+    });
+    const serverJsonPath = resolve(projectDir, 'server.json');
+    await writeFile(serverJsonPath, JSON.stringify(serverJson, null, 2) + '\n', 'utf-8');
+    logger.success(`Generated ${serverJsonPath}`);
+    // The registry validates that the npm package's `mcpName` matches the server
+    // name. Add/update it idempotently so `mcp-publisher publish` validates.
+    if (pkgJson.mcpName !== name) {
+        const updated = { ...pkgJson, mcpName: name };
+        await writeFile(pkgPath, JSON.stringify(updated, null, 2) + '\n', 'utf-8');
+        logger.info(`Set "mcpName": "${name}" in package.json (required for npm validation)`);
+    }
+    if (opts.push) {
+        await runMcpPublisher(projectDir);
+        return;
+    }
+    logger.info('');
+    logger.success(`Ready to publish ${name} to the official MCP Registry.`);
+    logger.info('Next steps:');
+    logger.info('  1. Publish the package to npm (the registry hosts metadata, not artifacts):');
+    logger.info('       npm publish --access public');
+    logger.info('  2. Install mcp-publisher: https://modelcontextprotocol.io/registry/quickstart');
+    logger.info('  3. Authenticate (the namespace must match your GitHub login):');
+    logger.info('       mcp-publisher login github');
+    logger.info('  4. Publish the server metadata:');
+    logger.info(`       cd ${projectDir} && mcp-publisher publish`);
+    logger.info('');
+    logger.info(`Re-run with --push to run step 4 automatically. Registry: ${OFFICIAL_REGISTRY_URL}`);
+}
+/** Normalize a package.json `repository` field to a plain https URL. */
+function extractRepoUrl(repository) {
+    let raw;
+    if (typeof repository === 'string') {
+        raw = repository;
+    }
+    else if (repository && typeof repository === 'object' && 'url' in repository) {
+        const u = repository.url;
+        if (typeof u === 'string')
+            raw = u;
+    }
+    if (!raw)
+        return undefined;
+    raw = raw.replace(/^git\+/, '');
+    const shorthand = raw.match(/^github:([^/]+\/[^/]+)$/);
+    if (shorthand)
+        raw = `https://github.com/${shorthand[1]}`;
+    return raw.replace(/\.git$/, '');
+}
+/** Best-effort `git remote get-url origin` for the project directory. */
+async function gitRemoteUrl(projectDir) {
+    try {
+        const { stdout } = await execFile('git', ['-C', projectDir, 'remote', 'get-url', 'origin']);
+        const url = stdout.trim();
+        return url ? url.replace(/^git\+/, '').replace(/\.git$/, '') : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Run the official `mcp-publisher publish` CLI in the project directory. */
+async function runMcpPublisher(projectDir) {
+    logger.info(`Publishing to ${OFFICIAL_REGISTRY_URL} via mcp-publisher...`);
+    try {
+        const { stdout, stderr } = await execFile('mcp-publisher', ['publish'], { cwd: projectDir });
+        if (stdout.trim())
+            logger.info(stdout.trim());
+        if (stderr.trim())
+            logger.info(stderr.trim());
+        logger.success('Published to the official MCP Registry.');
+    }
+    catch (err) {
+        const e = err;
+        if (e.code === 'ENOENT') {
+            logger.info('Install it: https://modelcontextprotocol.io/registry/quickstart');
+            await fail('mcp-publisher is not installed or not on PATH.', err);
+        }
+        else {
+            if (e.stdout?.trim())
+                logger.info(e.stdout.trim());
+            if (e.stderr?.trim())
+                logger.error(e.stderr.trim());
+            await fail('mcp-publisher publish failed. Ensure you ran `mcp-publisher login github` and published to npm first.', err);
+        }
+    }
+}

package/dist/commands/rescan.d.ts

@@ -0,0 +1,40 @@
+declare const _default: import("citty").CommandDef<{
+    project: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    url: {
+        type: "string";
+        description: string;
+    };
+    depth: {
+        type: "string";
+        description: string;
+    };
+    'max-pages': {
+        type: "string";
+        description: string;
+    };
+    heal: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    write: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    headless: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    format: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;

package/dist/commands/rescan.js

@@ -0,0 +1,255 @@
+import { defineCommand } from 'citty';
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { chromium } from 'playwright';
+import { crawlSite } from '../analyzer/site-crawler.js';
+import { validateSelector } from '../analyzer/selector-builder.js';
+import { detectAuthFlow } from '../analyzer/auth-detector.js';
+import { generateSiteTools } from '../site-transformer/tool-generator.js';
+import { healBrokenSelector } from '../site-transformer/selector-healer.js';
+import { diffSiteDescriptors } from '../rescan/diff-engine.js';
+import { collectLowConfidenceSelectors, summarizeRescan } from '../rescan/rescan-runner.js';
+import { emitSiteProject } from '../emitter/index.js';
+import { logger } from '../utils/logger.js';
+import { fail } from '../utils/fail.js';
+import { pathExists } from '../utils/fs.js';
+export default defineCommand({
+    meta: {
+        name: 'rescan',
+        description: "Re-crawl a generated website MCP server's target, diff against the embedded snapshot, heal broken selectors, and optionally regenerate",
+    },
+    args: {
+        project: {
+            type: 'positional',
+            description: 'Path to the generated site MCP server project',
+            required: true,
+        },
+        url: {
+            type: 'string',
+            description: 'Override the base URL to rescan (default: from the embedded descriptor)',
+        },
+        depth: {
+            type: 'string',
+            description: 'Crawl depth (default: from the embedded descriptor)',
+        },
+        'max-pages': {
+            type: 'string',
+            description: 'Maximum pages to crawl (default: page count of the embedded descriptor)',
+        },
+        heal: {
+            type: 'boolean',
+            description: 'LLM-heal low-confidence selectors (requires ANTHROPIC_API_KEY)',
+            default: true,
+        },
+        write: {
+            type: 'boolean',
+            description: 'Regenerate the project in place from the new snapshot',
+            default: false,
+        },
+        headless: {
+            type: 'boolean',
+            description: 'Run the crawl/heal browser headless',
+            default: true,
+        },
+        format: {
+            type: 'string',
+            description: 'Output format: "text" (default) or "json"',
+            default: 'text',
+        },
+    },
+    async run({ args }) {
+        const projectDir = resolve(args.project);
+        const descriptorPath = resolve(projectDir, 'src/site-descriptor.json');
+        if (!(await pathExists(descriptorPath))) {
+            return await fail(`No site snapshot at ${descriptorPath}. Is this a 'mcpmake from website' project?`);
+        }
+        let oldSite;
+        try {
+            oldSite = JSON.parse(await readFile(descriptorPath, 'utf-8'));
+        }
+        catch (err) {
+            return await fail(`Failed to read site snapshot: ${descriptorPath}`, err);
+        }
+        const baseUrl = args.url ?? oldSite.baseUrl;
+        const depth = args.depth ? parseInt(args.depth, 10) : oldSite.crawlDepth || 2;
+        // Default with headroom so newly-added pages are still discovered (a flat
+        // cap at the old page count would make rescan blind to site growth).
+        const maxPages = args['max-pages']
+            ? parseInt(args['max-pages'], 10)
+            : Math.max(oldSite.pages.length * 2, oldSite.pages.length + 5, 1);
+        const headless = args.headless ?? true;
+        logger.info(`Rescanning ${baseUrl} (depth ${depth}, max ${maxPages} pages)`);
+        let newSite;
+        try {
+            const result = await crawlSite({ url: baseUrl, depth, maxPages, headless });
+            newSite = result.siteDescriptor;
+        }
+        catch (err) {
+            return await fail(`Rescan crawl failed: ${baseUrl}`, err);
+        }
+        if (newSite.pages.length === 0) {
+            return await fail('Rescan crawl found no pages. Check that the URL is reachable.');
+        }
+        // Diff bumps from the OLD snapshot version.
+        newSite.version = oldSite.version;
+        const result = diffSiteDescriptors(oldSite, newSite);
+        // Heal the brittle (low-confidence) selectors in the fresh snapshot so the
+        // regenerated server gets more stable selectors than a bare re-crawl found.
+        const lows = collectLowConfidenceSelectors(newSite);
+        let healedCount = 0;
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (args.heal && lows.length > 0 && apiKey) {
+            logger.info(`Healing ${lows.length} low-confidence selector(s)…`);
+            healedCount = await healLowConfidenceSelectors(lows, headless);
+            logger.info(`Healed ${healedCount}/${lows.length} selector(s)`);
+        }
+        else if (args.heal && lows.length > 0 && !apiKey) {
+            logger.warn(`${lows.length} low-confidence selector(s) found, but ANTHROPIC_API_KEY is not set — skipping healing`);
+        }
+        const summary = summarizeRescan(result);
+        if (args.format === 'json') {
+            process.stdout.write(JSON.stringify({
+                summary,
+                healed: healedCount,
+                lowConfidence: lows.length,
+                brokenSelectors: result.brokenSelectors,
+                changes: result.changes,
+            }, null, 2) + '\n');
+        }
+        else {
+            printTextReport(summary, healedCount, lows.length);
+        }
+        if (args.write) {
+            await regenerate(projectDir, result.newSiteDescriptor);
+            logger.success(`Regenerated ${projectDir} (snapshot v${summary.newVersion})`);
+        }
+        else if (summary.totalChanges > 0 || healedCount > 0) {
+            logger.info('');
+            logger.info('Re-run with --write to regenerate the project from this snapshot.');
+        }
+    },
+});
+/**
+ * Open a browser and try to heal each low-confidence selector by navigating to
+ * its page, snapshotting the accessibility tree, asking the LLM for a better
+ * selector, and applying it only if it actually resolves on the live page.
+ * Mutates the selector objects in place (they are live references into the
+ * descriptor). Returns the number of selectors healed.
+ */
+async function healLowConfidenceSelectors(lows, headless) {
+    const byUrl = new Map();
+    for (const low of lows) {
+        const group = byUrl.get(low.pageUrl) ?? [];
+        group.push(low);
+        byUrl.set(low.pageUrl, group);
+    }
+    let healed = 0;
+    const browser = await chromium.launch({ headless });
+    try {
+        const context = await browser.newContext({ viewport: { width: 1280, height: 720 } });
+        const page = await context.newPage();
+        for (const [url, group] of byUrl) {
+            try {
+                await page.goto(url, { waitUntil: 'domcontentloaded', timeout: 15_000 });
+                await page.waitForTimeout(1000);
+            }
+            catch (err) {
+                logger.warn(`Could not load ${url} for healing: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+            let tree = '';
+            try {
+                // Modern Playwright accessibility tree (YAML); compact and selector-friendly.
+                tree = await page.locator('body').ariaSnapshot();
+            }
+            catch {
+                // Fall back to an empty tree; the healer will likely return null.
+            }
+            for (const low of group) {
+                const candidate = await healBrokenSelector(tree, low.selector, low.description);
+                if (!candidate)
+                    continue;
+                // Only apply selectors that actually resolve on the live page.
+                const working = await validateSelector(page, candidate);
+                if (working) {
+                    Object.assign(low.selector, candidate);
+                    healed += 1;
+                }
+            }
+        }
+    }
+    finally {
+        await browser.close().catch(() => { });
+    }
+    return healed;
+}
+/** Regenerate the project in place from a fresh (healed) descriptor. */
+async function regenerate(projectDir, descriptor) {
+    const metaPath = resolve(projectDir, 'mcpmake.site.json');
+    let meta;
+    if (await pathExists(metaPath)) {
+        meta = JSON.parse(await readFile(metaPath, 'utf-8'));
+    }
+    else {
+        logger.warn('mcpmake.site.json not found — regenerating with default settings');
+        meta = {
+            serverName: hostToName(descriptor.baseUrl),
+            serverVersion: '1.0.0',
+            transport: 'stdio',
+            baseUrl: descriptor.baseUrl,
+            envVars: [
+                {
+                    name: 'BASE_URL',
+                    description: 'Target website URL',
+                    required: true,
+                    example: descriptor.baseUrl,
+                },
+            ],
+            browserConfig: {
+                headless: true,
+                idleTimeoutMs: 5 * 60 * 1000,
+                viewport: { width: 1280, height: 720 },
+                maxSessions: 10,
+            },
+        };
+    }
+    const authFlow = detectAuthFlow(descriptor.pages);
+    if (authFlow) {
+        descriptor.authFlow = authFlow;
+    }
+    const tools = generateSiteTools(descriptor);
+    const manifest = {
+        ...meta,
+        siteDescriptor: descriptor,
+        tools,
+    };
+    await emitSiteProject(manifest, { outputDir: projectDir, force: true, dryRun: false });
+}
+function hostToName(baseUrl) {
+    let host = 'site';
+    try {
+        host = new URL(baseUrl).hostname;
+    }
+    catch {
+        // keep default
+    }
+    return (host
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '') || 'site');
+}
+function printTextReport(summary, healedCount, lowCount) {
+    const line = (label, c) => `${label}: pages ${c.page}, forms ${c.form}, fields ${c.field}, buttons ${c.button}, links ${c.link}`;
+    logger.info('');
+    logger.info(`Snapshot v${summary.previousVersion} → v${summary.newVersion}`);
+    logger.info(`  ${line('Added   ', summary.added)}`);
+    logger.info(`  ${line('Removed ', summary.removed)}`);
+    logger.info(`  ${line('Modified', summary.modified)}`);
+    logger.info(`  Broken selectors (low-confidence change): ${summary.brokenSelectors}`);
+    if (lowCount > 0) {
+        logger.info(`  Healed selectors: ${healedCount}/${lowCount}`);
+    }
+    if (summary.totalChanges === 0) {
+        logger.info('  No structural changes detected.');
+    }
+}

package/dist/commands/update.d.ts

@@ -0,0 +1,14 @@
+declare const _default: import("citty").CommandDef<{
+    spec: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    project: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+}>;
+export default _default;