@tellet/create 0.9.0 → 0.12.0

package/dist/index.js

@@ -1,337 +1,9 @@
 #!/usr/bin/env node
-import * as p from "@clack/prompts";
-import chalk from "chalk";
-import { generateAgents } from "./ai/generate.js";
-import { scaffoldProject } from "./scaffold/project.js";
-async function main() {
-    console.clear();
-    console.log();
-    console.log(chalk.bold(`  ${chalk.white("tel")}${chalk.yellow("let")} ${chalk.dim("— Build Your AI Company")}`));
-    console.log();
-    p.intro(chalk.bgHex("#8b5cf6").white(" @tellet/create "));
-    // Step 0: New or Connect
-    const modeChoice = await p.select({
-        message: "What would you like to do?",
-        options: [
-            {
-                value: "new",
-                label: "New",
-                hint: "Build a new AI company from scratch",
-            },
-            {
-                value: "connect",
-                label: "Connect",
-                hint: "Add AI agents to your existing business",
-            },
-        ],
-    });
-    if (p.isCancel(modeChoice)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const mode = modeChoice;
-    // Step 1: Company info
-    const company = await p.group({
-        name: () => p.text({
-            message: "What's your company name?",
-            placeholder: "Sunny Coffee",
-            validate: (v) => (!v ? "Company name is required" : undefined),
-        }),
-        description: () => p.text({
-            message: "Describe your business (what you do, who your customers are, what help you need):",
-            placeholder: "We sell specialty coffee subscriptions. Customers are coffee enthusiasts aged 25-45...",
-            validate: (v) => !v || v.length < 20
-                ? "Please provide at least a few sentences"
-                : undefined,
-        }),
-    }, {
-        onCancel: () => {
-            p.cancel("Setup cancelled.");
-            process.exit(0);
-        },
-    });
-    // Step 2: Deployment tier
-    const tierChoice = await p.select({
-        message: "Deployment mode:",
-        options: [
-            {
-                value: "quickstart",
-                label: "Quick Start",
-                hint: "Vercel + Supabase — free, instant deploy",
-            },
-            {
-                value: "cloud",
-                label: "Cloud",
-                hint: "Railway / Render / Fly.io — Docker, $5-20/mo",
-            },
-            {
-                value: "enterprise",
-                label: "Enterprise",
-                hint: "AWS CDK — auto-provision Lambda + RDS + CloudFront",
-            },
-        ],
-    });
-    if (p.isCancel(tierChoice)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const tier = tierChoice;
-    // Step 3: Choose AI provider
-    const providerChoice = await p.select({
-        message: "Choose your AI provider:",
-        options: [
-            {
-                value: "anthropic",
-                label: "Anthropic (Claude)",
-                hint: "recommended — also powers the Orchestrator",
-            },
-            {
-                value: "openai",
-                label: "OpenAI (GPT)",
-                hint: "uses gpt-4.1 for generation",
-            },
-        ],
-    });
-    if (p.isCancel(providerChoice)) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    const provider = providerChoice;
-    // Step 4: Get API key
-    const envKey = provider === "anthropic"
-        ? process.env.ANTHROPIC_API_KEY
-        : process.env.OPENAI_API_KEY;
-    const envName = provider === "anthropic" ? "ANTHROPIC_API_KEY" : "OPENAI_API_KEY";
-    const keyPrefix = provider === "anthropic" ? "sk-ant-" : "sk-";
-    const keyPlaceholder = provider === "anthropic" ? "sk-ant-..." : "sk-...";
-    let apiKey = envKey || "";
-    if (!apiKey) {
-        const keyInput = await p.text({
-            message: `Your ${provider === "anthropic" ? "Anthropic" : "OpenAI"} API key:`,
-            placeholder: keyPlaceholder,
-            validate: (v) => !v || !v.startsWith(keyPrefix)
-                ? `Please enter a valid key (starts with ${keyPrefix})`
-                : undefined,
-        });
-        if (p.isCancel(keyInput)) {
-            p.cancel("Setup cancelled.");
-            process.exit(0);
-        }
-        apiKey = keyInput;
-        process.env[envName] = apiKey;
-    }
-    else {
-        p.log.info(chalk.dim(`Using ${envName} from environment.`));
-    }
-    // Orchestrator always needs Anthropic
-    let anthropicKey = "";
-    if (provider === "anthropic") {
-        anthropicKey = apiKey;
-    }
-    else {
-        const existingKey = process.env.ANTHROPIC_API_KEY || "";
-        if (existingKey) {
-            anthropicKey = existingKey;
-            p.log.info(chalk.dim("Using ANTHROPIC_API_KEY for Orchestrator."));
-        }
-        else {
-            p.log.info(chalk.dim("The Orchestrator requires an Anthropic API key (Claude tool use)."));
-            const orchKeyInput = await p.text({
-                message: "Anthropic API key for Orchestrator:",
-                placeholder: "sk-ant-...",
-                validate: (v) => !v || !v.startsWith("sk-ant-")
-                    ? "Please enter a valid Anthropic key (starts with sk-ant-)"
-                    : undefined,
-            });
-            if (p.isCancel(orchKeyInput)) {
-                p.cancel("Setup cancelled.");
-                process.exit(0);
-            }
-            anthropicKey = orchKeyInput;
-        }
-    }
-    // Step 5: Generate agents + site content
-    const s = p.spinner();
-    s.start("Generating your AI team and website...");
-    let agents;
-    try {
-        agents = await generateAgents(company.name, company.description, provider);
-        s.stop("Your AI team is ready!");
-    }
-    catch (err) {
-        s.stop("Failed to generate agents.");
-        p.log.error(err instanceof Error ? err.message : "Check your API key");
-        p.cancel("Setup failed.");
-        process.exit(1);
-    }
-    // Step 6: Show agents + site preview
-    p.log.info(chalk.bold("Meet your team:"));
-    console.log();
-    for (const agent of agents.agents) {
-        console.log(`  ${chalk.hex("#8b5cf6").bold(agent.name)} ${chalk.dim(`(${agent.role})`)}`);
-        console.log(`  ${chalk.dim(agent.description)}`);
-        console.log();
-    }
-    if (agents.site && mode === "new") {
-        p.log.info(chalk.bold("Your website:"));
-        console.log(`  ${chalk.hex("#f59e0b")(agents.site.tagline)}`);
-        console.log(`  ${chalk.dim(agents.site.subtitle)}`);
-        console.log();
-    }
-    const confirm = await p.confirm({
-        message: "Looks good?",
-        initialValue: true,
-    });
-    if (p.isCancel(confirm) || !confirm) {
-        p.cancel("Setup cancelled.");
-        process.exit(0);
-    }
-    // Step 7a: Connect mode — website URL for KB
-    let websiteUrl = "";
-    if (mode === "connect") {
-        const urlInput = await p.text({
-            message: "Your existing website URL (for Knowledge Base crawling):",
-            placeholder: "https://my-business.com",
-        });
-        if (!p.isCancel(urlInput) && urlInput) {
-            websiteUrl = urlInput;
-        }
-    }
-    // Step 7b: Infrastructure setup (tier-dependent)
-    let supabaseUrl = "";
-    let supabaseKey = "";
-    if (tier === "quickstart") {
-        p.log.info(`${chalk.bold("Supabase setup")} ${chalk.dim("(free tier works fine)")}\n` +
-            `  ${chalk.dim("1.")} Create a project at ${chalk.cyan("https://supabase.com/dashboard/new")}\n` +
-            `  ${chalk.dim("2.")} Go to Settings → API to find your URL and keys`);
-        const supabase = await p.group({
-            url: () => p.text({
-                message: "Your Supabase project URL:",
-                placeholder: "https://xxx.supabase.co",
-                validate: (v) => !v || !v.includes("supabase")
-                    ? "Please enter a valid Supabase URL"
-                    : undefined,
-            }),
-            key: () => p.text({
-                message: "Your Supabase publishable key (anon/public):",
-                placeholder: "sb_publishable_...",
-                validate: (v) => (!v ? "Key is required" : undefined),
-            }),
-        }, {
-            onCancel: () => {
-                p.cancel("Setup cancelled.");
-                process.exit(0);
-            },
-        });
-        supabaseUrl = supabase.url;
-        supabaseKey = supabase.key;
-    }
-    else if (tier === "cloud") {
-        p.log.info(chalk.dim("Cloud mode: PostgreSQL runs in Docker. No Supabase needed."));
-    }
-    else {
-        p.log.info(`${chalk.bold("AWS Enterprise setup")}\n` +
-            `  ${chalk.dim("Requires:")} AWS CLI configured + CDK bootstrapped\n` +
-            `  ${chalk.dim("Cost:")} ~$5-15/mo (Lambda + RDS free tier)`);
-    }
-    // Step 8: Scaffold project
-    s.start("Creating your project...");
-    try {
-        const projectDir = await scaffoldProject({
-            company: {
-                name: company.name,
-                description: company.description,
-                industry: agents.industry,
-            },
-            agents: agents.agents,
-            site: agents.site,
-            provider,
-            tier,
-            mode,
-            websiteUrl,
-            infra: {
-                anthropicKey,
-                openaiKey: provider === "openai" ? apiKey : undefined,
-                supabaseUrl,
-                supabaseKey,
-            },
-        });
-        s.stop("Project created!");
-        const slug = company.name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .replace(/^-|-$/g, "");
-        const widgetSnippet = mode === "connect"
-            ? [
-                ``,
-                `${chalk.bold("Embed in your existing site:")}`,
-                `${chalk.cyan('<script src="https://YOUR_URL/widget.js"')}`,
-                `${chalk.cyan('  data-agent="' + agents.agents[0].id + '"')}`,
-                `${chalk.cyan('  data-api="https://YOUR_URL"></script>')}`,
-            ]
-            : [];
-        if (tier === "quickstart") {
-            p.note([
-                `cd ${slug}`,
-                `npm install`,
-                `npm run dev        ${chalk.dim("→ http://localhost:3000")}`,
-                ``,
-                `Dashboard:    ${chalk.dim("/dashboard")}`,
-                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
-                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
-                ...widgetSnippet,
-            ].join("\n"), mode === "connect" ? "Your AI agents are ready" : "Your AI company is ready");
-            p.outro(`Deploy: ${chalk.cyan("vercel deploy")}`);
-        }
-        else if (tier === "cloud") {
-            p.note([
-                `cd ${slug}`,
-                ``,
-                `${chalk.bold("Local development:")}`,
-                `docker compose up     ${chalk.dim("→ http://localhost:3000")}`,
-                ``,
-                `${chalk.bold("Deploy to Railway:")}`,
-                `railway login`,
-                `railway init`,
-                `railway add --plugin postgresql`,
-                `railway up`,
-                ``,
-                `Dashboard:    ${chalk.dim("/dashboard")}`,
-                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
-                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
-            ].join("\n"), "Your AI company is ready");
-            p.outro(`Or deploy to ${chalk.cyan("Render")}, ${chalk.cyan("Fly.io")}, or any Docker host`);
-        }
-        else {
-            p.note([
-                `cd ${slug}`,
-                ``,
-                `${chalk.bold("Local development:")}`,
-                `docker compose up     ${chalk.dim("→ http://localhost:3000")}`,
-                ``,
-                `${chalk.bold("Deploy to AWS:")}`,
-                `cd infra`,
-                `npm install`,
-                `npx cdk bootstrap     ${chalk.dim("(first time only)")}`,
-                `npx cdk deploy        ${chalk.dim("→ CloudFront URL in output")}`,
-                ``,
-                `${chalk.bold("Update API keys:")}`,
-                `aws secretsmanager put-secret-value \\`,
-                `  --secret-id ${slug}/api-keys \\`,
-                `  --secret-string '{"ANTHROPIC_API_KEY":"sk-ant-..."}'`,
-                ``,
-                `Dashboard:    ${chalk.dim("/dashboard")}`,
-                `Orchestrator: ${chalk.dim("floating button in dashboard")}`,
-                `Agents:       ${chalk.dim(`${agents.agents.length} active`)}`,
-                `Est. cost:    ${chalk.dim("$5-15/mo")}`,
-            ].join("\n"), "Your AI company is ready (AWS)");
-            p.outro(`Run ${chalk.cyan("cd infra && npx cdk deploy")} to provision AWS infrastructure`);
-        }
-    }
-    catch (err) {
-        s.stop("Failed to create project.");
-        p.log.error(err instanceof Error ? err.message : String(err));
-        process.exit(1);
-    }
-}
-main().catch(console.error);
+// Entry point for both `npx @tellet/create` and `tellet <command>`
+// Delegates to cli.ts which handles routing.
+import { run } from "./cli.js";
+const args = process.argv.slice(2);
+run(args).catch((err) => {
+    console.error(err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});

package/dist/mcp/server.d.ts

@@ -0,0 +1 @@
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,25 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import fs from "fs-extra";
+import path from "path";
+import { fileURLToPath } from "url";
+import { registerTools } from "./tools.js";
+async function getVersion() {
+    const __dirname = path.dirname(fileURLToPath(import.meta.url));
+    const pkg = await fs.readJSON(path.resolve(__dirname, "..", "..", "package.json"));
+    return pkg.version;
+}
+export async function startMcpServer() {
+    const version = await getVersion();
+    const server = new McpServer({
+        name: "tellet",
+        version,
+    }, {
+        instructions: "Tellet MCP server — manage AI agent projects. " +
+            "Use these tools inside a tellet project directory (one containing tellet.json). " +
+            "Tools: project_status, agent_list, agent_add, agent_remove, config_read, dev_start, deploy_info.",
+    });
+    registerTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}

package/dist/mcp/tools.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerTools(server: McpServer): void;

package/dist/mcp/tools.js

@@ -0,0 +1,264 @@
+import { z } from "zod";
+import fs from "fs-extra";
+import path from "path";
+import { spawn } from "child_process";
+import { loadConfig, saveConfig, nameToId, generateAgentFile, updateAgentRegistry, } from "../commands/shared.js";
+const VALID_ROLES = [
+    "customer_support",
+    "sales",
+    "marketing",
+    "operations",
+    "analytics",
+    "development",
+];
+export function registerTools(server) {
+    // ─── project_status ───────────────────────────────────
+    server.registerTool("project_status", {
+        title: "Project Status",
+        description: "Show tellet project status: company info, agents, channels, LLM config, and environment health.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const envPath = path.resolve(process.cwd(), ".env.local");
+        const envExists = await fs.pathExists(envPath);
+        const nodeModules = await fs.pathExists(path.resolve(process.cwd(), "node_modules"));
+        const enabledChannels = Object.entries(config.channels)
+            .filter(([, v]) => v.enabled)
+            .map(([k]) => k);
+        const text = [
+            `Company: ${config.company.name}`,
+            `Industry: ${config.company.industry}`,
+            `Mode: ${config.mode}`,
+            `Provider: ${config.llm.provider} (${config.llm.defaultModel})`,
+            `Agents: ${config.agents.length} (${config.agents.map((a) => a.name).join(", ")})`,
+            `Channels: ${enabledChannels.join(", ") || "none"}`,
+            `Storage: ${config.storage}`,
+            `.env.local: ${envExists ? "found" : "MISSING"}`,
+            `node_modules: ${nodeModules ? "installed" : "NOT INSTALLED"}`,
+        ].join("\n");
+        return { content: [{ type: "text", text }] };
+    });
+    // ─── agent_list ───────────────────────────────────────
+    server.registerTool("agent_list", {
+        title: "List Agents",
+        description: "List all agents in the tellet project with their roles, models, channels, and tools.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        if (config.agents.length === 0) {
+            return { content: [{ type: "text", text: "No agents configured." }] };
+        }
+        const lines = config.agents.map((a) => [
+            `- ${a.name} (${a.id})`,
+            `  Role: ${a.role}`,
+            `  Model: ${a.model}`,
+            `  Channels: ${a.channels.join(", ")}`,
+            `  Tools: ${a.tools.length > 0 ? a.tools.join(", ") : "none"}`,
+        ].join("\n"));
+        return { content: [{ type: "text", text: lines.join("\n\n") }] };
+    });
+    // ─── agent_add ────────────────────────────────────────
+    server.registerTool("agent_add", {
+        title: "Add Agent",
+        description: "Add a new AI agent to the tellet project. Updates tellet.json, creates the agent file, and updates the registry.",
+        inputSchema: z.object({
+            name: z.string().describe("Agent display name (e.g. Luna, Atlas)"),
+            role: z
+                .enum(VALID_ROLES)
+                .describe("Agent role"),
+            description: z
+                .string()
+                .describe("What this agent does (used in system prompt)"),
+        }),
+    }, async ({ name, role, description }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const id = nameToId(name);
+        if (!id) {
+            return {
+                content: [{ type: "text", text: "Error: Name must contain at least one letter or number." }],
+                isError: true,
+            };
+        }
+        if (config.agents.some((a) => a.id === id)) {
+            return {
+                content: [{ type: "text", text: `Error: Agent "${id}" already exists.` }],
+                isError: true,
+            };
+        }
+        const model = config.llm.defaultModel;
+        const systemPrompt = `You are ${name}, the ${role.replace(/_/g, " ")} agent for ${config.company.name}. ${description}`;
+        config.agents.push({
+            id,
+            name,
+            role,
+            model,
+            channels: ["web_chat"],
+            tools: role === "customer_support" ? ["search_knowledge"] : [],
+        });
+        await saveConfig(config);
+        const agentsDir = path.resolve(process.cwd(), "agents");
+        await fs.mkdirp(agentsDir);
+        await fs.writeFile(path.join(agentsDir, `${id}.ts`), generateAgentFile({ id, name, role, model, systemPrompt }));
+        await updateAgentRegistry(config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Added agent "${name}" (${role})\nID: ${id}\nFile: agents/${id}.ts\nTotal agents: ${config.agents.length}`,
+                },
+            ],
+        };
+    });
+    // ─── agent_remove ─────────────────────────────────────
+    server.registerTool("agent_remove", {
+        title: "Remove Agent",
+        description: "Remove an agent from the tellet project by ID.",
+        inputSchema: z.object({
+            id: z.string().describe("Agent ID to remove"),
+        }),
+    }, async ({ id }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const agent = config.agents.find((a) => a.id === id);
+        if (!agent) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `Error: Agent "${id}" not found. Available: ${config.agents.map((a) => a.id).join(", ")}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        config.agents = config.agents.filter((a) => a.id !== id);
+        await saveConfig(config);
+        const agentPath = path.resolve(process.cwd(), "agents", `${id}.ts`);
+        if (await fs.pathExists(agentPath)) {
+            await fs.remove(agentPath);
+        }
+        await updateAgentRegistry(config);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Removed agent "${agent.name}" (${id})\nRemaining agents: ${config.agents.length}`,
+                },
+            ],
+        };
+    });
+    // ─── config_read ──────────────────────────────────────
+    server.registerTool("config_read", {
+        title: "Read Config",
+        description: "Read the full tellet.json configuration file.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const configPath = path.resolve(process.cwd(), "tellet.json");
+        if (!(await fs.pathExists(configPath))) {
+            return configError();
+        }
+        const raw = await fs.readFile(configPath, "utf-8");
+        return { content: [{ type: "text", text: raw }] };
+    });
+    // ─── dev_start ────────────────────────────────────────
+    server.registerTool("dev_start", {
+        title: "Start Dev Server",
+        description: "Start the Next.js development server (next dev). Launches in the background — success means the process was spawned, not that the server is healthy.",
+        inputSchema: z.object({
+            port: z
+                .number()
+                .int()
+                .min(1024)
+                .max(65535)
+                .optional()
+                .describe("Port number (default: 3000)"),
+        }),
+    }, async ({ port }) => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const nodeModules = await fs.pathExists(path.resolve(process.cwd(), "node_modules"));
+        if (!nodeModules) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: "Error: node_modules not found. Run npm install first.",
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const args = ["next", "dev"];
+        if (port)
+            args.push("--port", String(port));
+        const child = spawn("npx", args, {
+            cwd: process.cwd(),
+            detached: true,
+            stdio: "ignore",
+        });
+        child.unref();
+        const actualPort = port || 3000;
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `Dev server spawned for ${config.company.name} on http://localhost:${actualPort}\nPID: ${child.pid}\nNote: Check the port is not already in use.`,
+                },
+            ],
+        };
+    });
+    // ─── deploy_info ──────────────────────────────────────
+    server.registerTool("deploy_info", {
+        title: "Deploy Info",
+        description: "Show deployment options and commands based on the project structure.",
+        inputSchema: z.object({}),
+    }, async () => {
+        const config = await tryLoadConfig();
+        if (!config)
+            return configError();
+        const cwd = process.cwd();
+        const hasInfra = await fs.pathExists(path.join(cwd, "infra"));
+        const hasDocker = await fs.pathExists(path.join(cwd, "docker-compose.yml"));
+        const hasRailway = await fs.pathExists(path.join(cwd, "railway.toml"));
+        const options = [];
+        options.push("## Vercel (recommended for Quick Start)", "```", "npx vercel", "```", "");
+        if (hasRailway || hasDocker) {
+            options.push("## Railway", "```", "railway login", "railway init", "railway add --plugin postgresql", "railway up", "```", "");
+        }
+        if (hasDocker) {
+            options.push("## Docker", "```", "docker build -t tellet .", "docker compose up -d", "```", "Works with Render, Fly.io, DigitalOcean, or any Docker host.", "");
+        }
+        if (hasInfra) {
+            options.push("## AWS CDK", "```", "cd infra && npm install", "npx cdk bootstrap  # first time only", "npx cdk deploy", "```", "");
+        }
+        return { content: [{ type: "text", text: options.join("\n") }] };
+    });
+}
+// ─── Helpers ──────────────────────────────────────────
+async function tryLoadConfig() {
+    try {
+        return await loadConfig();
+    }
+    catch {
+        return null;
+    }
+}
+function configError() {
+    return {
+        content: [
+            {
+                type: "text",
+                text: "No tellet.json found in current directory. Make sure the MCP server is running from inside a tellet project.",
+            },
+        ],
+        isError: true,
+    };
+}

package/dist/scaffold/project.js

@@ -181,7 +181,7 @@ export default defineAgent({
 }
 function generateMigration(agents, company) {
     const seedValues = agents
-        .map((a) => `('${a.id}', '${a.name}', '${a.role}', ${pgEscape(a.systemPrompt)}, '${a.model}', 'active', '{}')`)
+        .map((a) => `(${pgEscape(a.id)}, ${pgEscape(a.name)}, ${pgEscape(a.role)}, ${pgEscape(a.systemPrompt)}, ${pgEscape(a.model)}, 'active', '{}')`)
         .join(",\n");
     return `-- tellet schema
 

package/dist/scaffold-flow.d.ts

@@ -0,0 +1 @@
+export declare function main(): Promise<void>;