@tellet/create 0.8.3 → 0.10.0

package/README.md

@@ -1,188 +1,154 @@
-# @tellet/create
+# Tell it. Let it.
 
-> The open-source platform for running an Agentic Company.
+> AI agents that run your business — email, delegate, schedule, embed.
 
 ```bash
 npx @tellet/create
 ```
 
-tellet is a management platform for AI-powered companies. One command generates your AI agent team, website, dashboard, Knowledge Base, and Orchestrator — ready to deploy anywhere.
+Or start instantly at [tellet.com](https://tellet.com) — no setup required.
 
-## What you get
+---
 
-- **AI Agent Team** — 3-5 agents auto-generated for your business (CS, marketing, sales, ops)
-- **Orchestrator** — Manage your entire company through conversation
-- **Knowledge Base** — pgvector-powered, agents reference it for accurate answers
-- **Dashboard** — Stats, agent chat, conversations, onboarding
-- **Tool Marketplace** — Stripe, Email, GitHub, Slack, Notion via MCP
-- **Embeddable Widget** — One script tag to add AI chat to any website
-- **3-Tier Deployment** — Free (Vercel) / Cloud (Railway) / Enterprise (AWS)
+tellet generates an AI agent team for your business. Agents don't just chat — they send emails, delegate tasks to each other, run scheduled automations, and serve customers through an embeddable widget.
 
-## How it works
+## What agents can do
 
-```
-npx @tellet/create
+- **Email customers** — Send follow-ups, confirmations, and outreach via Resend
+- **Delegate to each other** — Support agent routes billing questions to sales automatically
+- **Run on schedule** — Daily reports, weekly summaries, automated follow-ups via cron
+- **Search knowledge** — Reference your product info, policies, and FAQ for accurate answers
+- **Serve customers anywhere** — Embeddable widget for any website, one script tag
 
-? New or Connect?          → New business or add AI to existing
-? Deployment?              → Quick Start / Cloud / Enterprise
-? AI Provider?             → Anthropic / OpenAI
-? Company name?            → Sunny Coffee
-? Describe your business   → We sell specialty coffee...
+## Two ways to start
 
-  Generating your AI team and website...
+### Hosted (tellet.com) — recommended
 
-  Your team:
-  Barista (customer_support)
-  Roaster (marketing)
-  Grinder (sales)
+1. Sign up at [tellet.com](https://tellet.com)
+2. Describe your business in one sentence
+3. AI generates your agent team with email, delegation, and scheduling
+4. Embed the widget on your site, agents go to work
 
-  Your website:
-  "Coffee worth waking up for"
-
-  ✓ Project created!
-```
-
-## Quick start
+### Self-hosted (CLI)
 
 ```bash
-# Quick Start (Vercel + Supabase, free)
 npx @tellet/create
 cd your-company
 npm install && npm run dev
-
-# Cloud (Docker + Railway, $5/mo)
-npx @tellet/create  # choose "Cloud"
-cd your-company
-docker compose up         # local dev
-railway up                # deploy
-
-# Enterprise (AWS CDK, $5-15/mo)
-npx @tellet/create  # choose "Enterprise"
-cd your-company/infra
-npm install && npx cdk deploy
 ```
 
-## Architecture
+## How it works
 
 ```
-┌─ tellet Platform ─────────────────────────┐
-│  Owner ↔ Orchestrator                      │
-│              ↕                             │
-│  Agent Team (CS · Marketing · Sales · Ops) │
-│              ↕                             │
-│  MCP Bridge Layer                          │
-│  (KB, Stripe, DB, Email, Custom API...)    │
-└────────────────────────────────────────────┘
-```
+You: "I run a coffee shop called Sunny Coffee"
 
-## Project structure
+  Generating your AI team...
 
-```
-your-company/
-├── agents/                # AI agent definitions (auto-generated)
-├── app/
-│   ├── (site)/            # Public website with chat widget
-│   ├── (dashboard)/       # Management dashboard + Orchestrator
-│   └── api/
-│       ├── chat/          # Streaming chat API (tool use)
-│       ├── orchestrator/  # Orchestrator API (tool use loop)
-│       └── cron/          # Scheduled agent tasks
-├── components/
-│   ├── chat/              # ChatWidget, Markdown
-│   ├── dashboard/         # Sidebar, Stats, AgentChat, Orchestrator
-│   └── sections/          # Landing page sections
-├── lib/
-│   ├── engine/            # Agent runtime with tool use agentic loop
-│   ├── providers/         # LLM providers (Anthropic, OpenAI)
-│   ├── mcp/               # MCP client, Knowledge Base, tool registry
-│   ├── orchestrator/      # Orchestrator tools + executor
-│   └── scheduler.ts       # Cron/heartbeat agent scheduler
-├── public/widget.js       # Embeddable chat widget
-├── tellet.json            # Configuration (single source of truth)
-├── Dockerfile             # Docker deployment (Cloud/Enterprise)
-├── docker-compose.yml     # Local dev with PostgreSQL + pgvector
-├── railway.toml           # Railway auto-deploy
-└── infra/                 # AWS CDK (Enterprise only)
-```
+  Your team:
+  Barista (customer_support) — emails, knowledge, delegation
+  Roaster (marketing)       — emails, knowledge, delegation
+  Grinder (sales)           — emails, knowledge, delegation
 
-## Orchestrator
+  Orchestrator tools:
+  ✓ schedule_task        — cron-based agent automation
+  ✓ list_scheduled_tasks — view all schedules
+  ✓ cancel_scheduled_task
 
-The Orchestrator is your AI company manager. Talk to it from the dashboard:
+  ✓ Your AI company is live!
+```
 
-- "Show my stats" — conversations, messages, costs
-- "Update the website tagline" — modifies site content
-- "Add Stripe to my agents" — installs tools from marketplace
-- "Schedule marketing to post daily at 9am" — sets up cron tasks
-- "Add our refund policy to the Knowledge Base" — agents reference it
+## Architecture
 
-## Tool Marketplace
+```
+┌─ tellet Platform ──────────────────────────────────┐
+│                                                     │
+│  Owner ↔ Orchestrator (schedule, manage, configure) │
+│              ↕                                     │
+│  Agent Team (CS · Marketing · Sales · Ops)         │
+│     ↕ delegate_to_agent ↕                          │
+│  Actions: email · search · schedule                │
+│              ↕                                     │
+│  Channels: dashboard · widget · cron               │
+│                                                     │
+└─────────────────────────────────────────────────────┘
+```
 
-Connect tools via the Orchestrator or `tellet.json`:
+## Agent capabilities by role
 
-| Tool | Package | Use case |
-|------|---------|----------|
-| Stripe | `@stripe/mcp` | Payments, invoices, subscriptions |
-| Email | `resend-mcp` | Send emails, campaigns |
-| GitHub | `@modelcontextprotocol/server-github` | Issues, PRs, repos |
-| Slack | `@anthropic-ai/mcp-server-slack` | Messages, channels |
-| Notion | `@anthropic-ai/mcp-server-notion` | Docs, databases |
+| Role | search_knowledge | send_email | delegate_to_agent |
+|------|:---:|:---:|:---:|
+| customer_support | Y | Y | Y |
+| sales | Y | Y | Y |
+| marketing | Y | Y | Y |
+| operations | Y | Y | Y |
+| analytics | Y | - | Y |
 
-19,000+ MCP servers available via the [MCP Registry](https://registry.modelcontextprotocol.io/).
+## Orchestrator commands
 
-## Deployment options
+The Orchestrator manages your AI company through conversation:
 
-| Tier | Provider | Cost | Best for |
-|------|----------|------|----------|
-| Quick Start | Vercel + Supabase | $0 | Prototyping, new business |
-| Cloud | Railway / Render / Fly.io | $5-20/mo | Production, startups |
-| Enterprise | AWS CDK (Lambda + RDS) | $5-15/mo | Scale, existing AWS |
+- "Schedule marketing to send a weekly summary every Monday 9am"
+- "Show all scheduled tasks"
+- "Add our refund policy to the Knowledge Base"
+- "Update the support agent's system prompt"
+- "Show my stats"
 
-## Connect mode
+## Embeddable widget
 
-Already have a business? Use Connect mode:
+Add AI chat to any website:
 
-```bash
-npx @tellet/create  # choose "Connect"
+```html
+<script src="https://tellet.com/widget.js"></script>
+<script>
+  Tellet.init({ companyId: "your-company-id" });
+</script>
 ```
 
-- Skips site generation, keeps dashboard + API
-- Embeddable widget for your existing site:
+Features: dark/light theme, streaming responses, session persistence, mobile responsive.
 
-```html
-<script src="https://your-tellet.com/widget.js"
-        data-agent="support"
-        data-api="https://your-tellet.com"></script>
-```
+## Project structure (self-hosted)
 
-## Configuration
-
-All configuration lives in `tellet.json`:
-
-```json
-{
-  "company": { "name": "Sunny Coffee", "industry": "Food & Beverage" },
-  "mode": "new",
-  "llm": { "provider": "anthropic", "defaultModel": "claude-sonnet-4-6" },
-  "agents": [
-    { "id": "barista", "role": "customer_support", "tools": ["search_knowledge"] },
-    { "id": "roaster", "role": "marketing", "tools": ["email"] }
-  ],
-  "tools": {
-    "search_knowledge": { "type": "builtin" },
-    "email": { "type": "mcp", "package": "resend-mcp" }
-  },
-  "site": { "tagline": "Coffee worth waking up for", "..." : "..." }
-}
+```
+your-company/
+├─�� app/
+│   ├── (site)/             # Public website with chat widget
+│   ├── (dashboard)/        # Management dashboard + Orchestrator
+│   └── api/
+│       ├── chat/           # Agent chat (SSE, tool use loop)
+│       ├── orchestrator/   # Orchestrator (scheduling, management)
+│       ├── cron/           # Scheduled task execution
+│       └── widget/         # Public widget API (CORS, no auth)
+├── lib/
+│   ├── engine/             # Agent runtime with agentic loop
+│   ├── actions/            # Role-based tools (email, delegate, search)
+│   ├── scheduling/         # Cron parser + task executor
+│   ├── orchestrator/       # Orchestrator tools + executor
+│   ├── providers/          # LLM providers (Anthropic, OpenAI)
+│   └── mcp/                # Knowledge base, tool registry
+├── public/widget.js        # Embeddable chat widget
+├── supabase/migrations/    # Database schema
+└── vercel.json             # Cron configuration
 ```
 
 ## Tech stack
 
 - [Next.js 16](https://nextjs.org/) — App framework
-- [PostgreSQL + pgvector](https://github.com/pgvector/pgvector) — Database + vector search
-- [MCP](https://modelcontextprotocol.io/) — Tool integration protocol
+- [Supabase](https://supabase.com/) — Auth, database, pgvector, RLS
 - [Anthropic Claude](https://anthropic.com/) / [OpenAI](https://openai.com/) — AI models
+- [Resend](https://resend.com/) — Email delivery
+- [Vercel Cron](https://vercel.com/docs/cron-jobs) — Scheduled task execution
 - [Tailwind CSS 4](https://tailwindcss.com/) — Styling
-- [Framer Motion](https://www.framer.com/motion/) — Animations
+
+## Environment variables
+
+| Variable | Required | Description |
+|----------|:---:|-------------|
+| `NEXT_PUBLIC_SUPABASE_URL` | Y | Supabase project URL |
+| `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY` | Y | Supabase publishable key |
+| `SUPABASE_SERVICE_ROLE_KEY` | Y | Supabase service role key |
+| `ANTHROPIC_API_KEY` | Y | Claude API key |
+| `RESEND_API_KEY` | - | Resend API key (for email) |
+| `CRON_SECRET` | - | Secret for cron endpoint auth |
 
 ## License
 
@@ -190,6 +156,6 @@ MIT
 
 ## Links
 
-- [tellet.com](https://tellet.com) — Website
+- [tellet.com](https://tellet.com) — Hosted platform (free)
 - [GitHub](https://github.com/agentic-company/tellet) — Source code
-- [npm](https://www.npmjs.com/package/@tellet/create) — Package
+- [npm](https://www.npmjs.com/package/@tellet/create) — CLI package

package/dist/index.js

@@ -3,6 +3,8 @@ import * as p from "@clack/prompts";
 import chalk from "chalk";
 import { generateAgents } from "./ai/generate.js";
 import { scaffoldProject } from "./scaffold/project.js";
+import { setupSupabase } from "./setup/supabase.js";
+import { installDependencies } from "./setup/deps.js";
 async function main() {
     console.clear();
     console.log();
@@ -198,33 +200,15 @@ async function main() {
         }
     }
     // Step 7b: Infrastructure setup (tier-dependent)
+    // For quickstart: we'll collect Supabase info now, but may override
+    // with automated setup after scaffolding
     let supabaseUrl = "";
     let supabaseKey = "";
+    let useAutomatedSupabase = false;
     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;
+        // We'll handle Supabase setup after scaffold for CLI automation
+        // For now, just mark that we need it
+        useAutomatedSupabase = true;
     }
     else if (tier === "cloud") {
         p.log.info(chalk.dim("Cloud mode: PostgreSQL runs in Docker. No Supabase needed."));
@@ -236,6 +220,10 @@ async function main() {
     }
     // Step 8: Scaffold project
     s.start("Creating your project...");
+    const slug = company.name
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
     try {
         const projectDir = await scaffoldProject({
             company: {
@@ -252,15 +240,111 @@ async function main() {
             infra: {
                 anthropicKey,
                 openaiKey: provider === "openai" ? apiKey : undefined,
-                supabaseUrl,
-                supabaseKey,
+                supabaseUrl: supabaseUrl || "PLACEHOLDER",
+                supabaseKey: supabaseKey || "PLACEHOLDER",
             },
         });
         s.stop("Project created!");
-        const slug = company.name
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, "-")
-            .replace(/^-|-$/g, "");
+        // ─────────────────────────────────────────────────────────
+        // Post-scaffold automation
+        // ─────────────────────────────────────────────────────────
+        // Step 9: Supabase setup (quickstart only)
+        if (tier === "quickstart" && useAutomatedSupabase) {
+            const result = await setupSupabase(projectDir);
+            if (result.method === "local" && result.credentials) {
+                // Auto-detected credentials from local Supabase
+                supabaseUrl = result.credentials.url;
+                supabaseKey = result.credentials.anonKey;
+                // Rewrite .env.local with real credentials
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                    serviceRoleKey: result.credentials.serviceRoleKey,
+                });
+                p.log.success(chalk.green("Supabase configured automatically!") +
+                    chalk.dim(` → ${supabaseUrl}`));
+            }
+            else if (result.method === "remote") {
+                // Remote linked — user needs to provide URL/key for .env
+                p.log.info(chalk.dim("Project linked. Get your URL and key from Settings → API."));
+                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;
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                });
+            }
+            else {
+                // Manual fallback — same as before
+                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;
+                const { writeEnvFile } = await import("./setup/env.js");
+                await writeEnvFile(projectDir, {
+                    anthropicKey,
+                    openaiKey: provider === "openai" ? apiKey : undefined,
+                    supabaseUrl,
+                    supabaseKey,
+                });
+            }
+        }
+        // Step 10: Install dependencies
+        const installConfirm = await p.confirm({
+            message: "Install dependencies now? (npm install)",
+            initialValue: true,
+        });
+        if (!p.isCancel(installConfirm) && installConfirm) {
+            await installDependencies(projectDir);
+        }
+        // ─────────────────────────────────────────────────────────
+        // Final output
+        // ─────────────────────────────────────────────────────────
         const widgetSnippet = mode === "connect"
             ? [
                 ``,
@@ -270,11 +354,12 @@ async function main() {
                 `${chalk.cyan('  data-api="https://YOUR_URL"></script>')}`,
             ]
             : [];
+        const didInstall = !p.isCancel(installConfirm) && installConfirm === true;
+        const devCmd = didInstall ? "npm run dev" : "npm install && npm run dev";
         if (tier === "quickstart") {
             p.note([
                 `cd ${slug}`,
-                `npm install`,
-                `npm run dev        ${chalk.dim("→ http://localhost:3000")}`,
+                `${devCmd}        ${chalk.dim("→ http://localhost:3000")}`,
                 ``,
                 `Dashboard:    ${chalk.dim("/dashboard")}`,
                 `Orchestrator: ${chalk.dim("floating button in dashboard")}`,

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/setup/deps.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Run `npm install` in the project directory with live output.
+ */
+export declare function installDependencies(projectDir: string): Promise<boolean>;

package/dist/setup/deps.js

@@ -0,0 +1,24 @@
+import { spawnSync } from "child_process";
+import * as p from "@clack/prompts";
+/**
+ * Run `npm install` in the project directory with live output.
+ */
+export async function installDependencies(projectDir) {
+    const s = p.spinner();
+    s.start("Installing dependencies...");
+    const result = spawnSync("npm", ["install"], {
+        cwd: projectDir,
+        stdio: "pipe",
+        timeout: 300_000,
+    });
+    if (result.status !== 0) {
+        s.stop("Failed to install dependencies.");
+        const stderr = result.stderr?.toString().trim();
+        if (stderr) {
+            p.log.error(stderr.slice(0, 500));
+        }
+        return false;
+    }
+    s.stop("Dependencies installed!");
+    return true;
+}

package/dist/setup/env.d.ts

@@ -0,0 +1,12 @@
+interface EnvOptions {
+    anthropicKey: string;
+    openaiKey?: string;
+    supabaseUrl: string;
+    supabaseKey: string;
+    serviceRoleKey?: string;
+}
+/**
+ * Write (or overwrite) the .env.local file with Supabase + API credentials.
+ */
+export declare function writeEnvFile(projectDir: string, options: EnvOptions): Promise<void>;
+export {};

package/dist/setup/env.js

@@ -0,0 +1,26 @@
+import fs from "fs-extra";
+import path from "path";
+/** Escape a value for .env files — wrap in quotes if it contains special chars. */
+function envQuote(v) {
+    if (/[\s#"'\\$`!]/.test(v) || v.includes("\n")) {
+        return `"${v.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\n/g, "\\n")}"`;
+    }
+    return v;
+}
+/**
+ * Write (or overwrite) the .env.local file with Supabase + API credentials.
+ */
+export async function writeEnvFile(projectDir, options) {
+    const lines = [
+        `# Orchestrator (always Anthropic)`,
+        `ANTHROPIC_API_KEY=${envQuote(options.anthropicKey)}`,
+    ];
+    if (options.openaiKey) {
+        lines.push(`OPENAI_API_KEY=${envQuote(options.openaiKey)}`);
+    }
+    lines.push(``, `# Supabase`, `NEXT_PUBLIC_SUPABASE_URL=${envQuote(options.supabaseUrl)}`, `NEXT_PUBLIC_SUPABASE_PUBLISHABLE_KEY=${envQuote(options.supabaseKey)}`);
+    if (options.serviceRoleKey) {
+        lines.push(`SUPABASE_SERVICE_ROLE_KEY=${envQuote(options.serviceRoleKey)}`);
+    }
+    await fs.writeFile(path.join(projectDir, ".env.local"), lines.join("\n") + "\n");
+}

package/dist/setup/supabase.d.ts

@@ -0,0 +1,36 @@
+/** Check if the Supabase CLI is installed and accessible. */
+export declare function hasSupabaseCLI(): boolean;
+/** Check if Docker is running (required for `supabase start`). */
+export declare function hasDocker(): boolean;
+export interface SupabaseCredentials {
+    url: string;
+    anonKey: string;
+    serviceRoleKey?: string;
+}
+/**
+ * Initialize Supabase in the project directory.
+ * Creates supabase/config.toml if not already present.
+ */
+export declare function supabaseInit(projectDir: string): boolean;
+/**
+ * Start local Supabase (Docker containers).
+ * Returns credentials on success, null on failure.
+ */
+export declare function supabaseStartLocal(projectDir: string): Promise<SupabaseCredentials | null>;
+/**
+ * Link to a remote Supabase project.
+ * Prompts for project ref, runs `supabase link`.
+ */
+export declare function supabaseLinkRemote(projectDir: string): Promise<boolean>;
+/**
+ * Push migrations to the database.
+ */
+export declare function supabasePushMigrations(projectDir: string): Promise<boolean>;
+/**
+ * Full Supabase setup flow for quickstart tier.
+ * Returns credentials or null if user chose manual setup.
+ */
+export declare function setupSupabase(projectDir: string): Promise<{
+    credentials: SupabaseCredentials | null;
+    method: "local" | "remote" | "manual";
+}>;

package/dist/setup/supabase.js

@@ -0,0 +1,207 @@
+import { execFileSync, spawnSync } from "child_process";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+/** Check if the Supabase CLI is installed and accessible. */
+export function hasSupabaseCLI() {
+    try {
+        execFileSync("supabase", ["--version"], { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Check if Docker is running (required for `supabase start`). */
+export function hasDocker() {
+    try {
+        execFileSync("docker", ["info"], { stdio: "ignore", timeout: 5000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Parse `supabase status` output to extract local dev credentials.
+ * The output format is like:
+ *   API URL: http://127.0.0.1:54321
+ *   anon key: eyJ...
+ *   service_role key: eyJ...
+ */
+function parseSupabaseStatus(output) {
+    const urlMatch = output.match(/API URL:\s*(http\S+)/);
+    const anonMatch = output.match(/anon key:\s*(\S+)/);
+    const serviceMatch = output.match(/service_role key:\s*(\S+)/);
+    if (!urlMatch || !anonMatch)
+        return null;
+    return {
+        url: urlMatch[1],
+        anonKey: anonMatch[1],
+        serviceRoleKey: serviceMatch?.[1],
+    };
+}
+/**
+ * Run supabase CLI command in a directory, returning stdout.
+ */
+function runSupabase(args, cwd) {
+    return execFileSync("supabase", args, {
+        cwd,
+        encoding: "utf-8",
+        timeout: 120_000,
+    });
+}
+/**
+ * Run supabase CLI with live stdio (visible to user).
+ * Returns the exit code.
+ */
+function runSupabaseLive(args, cwd) {
+    const result = spawnSync("supabase", args, {
+        cwd,
+        stdio: "inherit",
+        timeout: 300_000,
+    });
+    return result.status ?? 1;
+}
+/**
+ * Initialize Supabase in the project directory.
+ * Creates supabase/config.toml if not already present.
+ */
+export function supabaseInit(projectDir) {
+    try {
+        runSupabase(["init", "--with-intellij-settings=false", "--with-vscode-settings=false"], projectDir);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Start local Supabase (Docker containers).
+ * Returns credentials on success, null on failure.
+ */
+export async function supabaseStartLocal(projectDir) {
+    p.log.info(chalk.dim("Starting local Supabase (this may take a minute on first run)..."));
+    const code = runSupabaseLive(["start"], projectDir);
+    if (code !== 0) {
+        p.log.error("Failed to start local Supabase.");
+        return null;
+    }
+    p.log.success("Local Supabase is running!");
+    // Extract credentials from status
+    try {
+        const output = runSupabase(["status"], projectDir);
+        return parseSupabaseStatus(output);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Link to a remote Supabase project.
+ * Prompts for project ref, runs `supabase link`.
+ */
+export async function supabaseLinkRemote(projectDir) {
+    const refInput = await p.text({
+        message: "Supabase project ref (from Dashboard → Settings → General):",
+        placeholder: "abcdefghijklmnopqrst",
+        validate: (v) => !v || v.length < 10
+            ? "Please enter a valid project ref"
+            : undefined,
+    });
+    if (p.isCancel(refInput))
+        return false;
+    p.log.info(chalk.dim("Linking to Supabase project (follow the prompts below)..."));
+    const code = runSupabaseLive(["link", "--project-ref", refInput], projectDir);
+    if (code !== 0) {
+        p.log.error("Failed to link project.");
+        return false;
+    }
+    p.log.success("Linked to Supabase project!");
+    return true;
+}
+/**
+ * Push migrations to the database.
+ */
+export async function supabasePushMigrations(projectDir) {
+    p.log.info(chalk.dim("Applying database migrations..."));
+    const code = runSupabaseLive(["db", "push"], projectDir);
+    if (code !== 0) {
+        p.log.error("Migration push failed.");
+        return false;
+    }
+    p.log.success("Migrations applied!");
+    return true;
+}
+/**
+ * Full Supabase setup flow for quickstart tier.
+ * Returns credentials or null if user chose manual setup.
+ */
+export async function setupSupabase(projectDir) {
+    const cliAvailable = hasSupabaseCLI();
+    const dockerAvailable = hasDocker();
+    if (!cliAvailable) {
+        p.log.info(chalk.dim("Supabase CLI not found. Install it for automated setup:\n" +
+            "  brew install supabase/tap/supabase\n" +
+            "  — or —\n" +
+            "  npx supabase --version"));
+        return { credentials: null, method: "manual" };
+    }
+    // Build options based on what's available
+    const options = [];
+    if (dockerAvailable) {
+        options.push({
+            value: "local",
+            label: "Local development",
+            hint: "supabase start — runs Postgres + Auth locally via Docker",
+        });
+    }
+    options.push({
+        value: "remote",
+        label: "Remote project",
+        hint: "Link to an existing Supabase project",
+    }, {
+        value: "manual",
+        label: "Manual setup",
+        hint: "I'll enter the URL and key myself",
+    });
+    if (!dockerAvailable) {
+        p.log.info(chalk.dim("Docker not detected — local Supabase requires Docker Desktop."));
+    }
+    const choice = await p.select({
+        message: "Supabase setup:",
+        options,
+    });
+    if (p.isCancel(choice)) {
+        return { credentials: null, method: "manual" };
+    }
+    const method = choice;
+    if (method === "manual") {
+        return { credentials: null, method: "manual" };
+    }
+    // Initialize supabase in project
+    const inited = supabaseInit(projectDir);
+    if (!inited) {
+        p.log.error("Failed to initialize Supabase in the project directory.");
+        return { credentials: null, method: "manual" };
+    }
+    if (method === "local") {
+        const creds = await supabaseStartLocal(projectDir);
+        if (creds) {
+            // Apply migrations to local DB
+            await supabasePushMigrations(projectDir);
+        }
+        return { credentials: creds, method: "local" };
+    }
+    // Remote
+    const linked = await supabaseLinkRemote(projectDir);
+    if (linked) {
+        const pushConfirm = await p.confirm({
+            message: "Apply database migrations now?",
+            initialValue: true,
+        });
+        if (!p.isCancel(pushConfirm) && pushConfirm) {
+            await supabasePushMigrations(projectDir);
+        }
+    }
+    return { credentials: null, method: "remote" };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@tellet/create",
-  "version": "0.8.3",
-  "description": "The open-source platform for running an Agentic Company",
+  "version": "0.10.0",
+  "description": "AI agents that run your business — email, delegate, schedule, embed. One command.",
   "type": "module",
   "bin": {
     "create": "dist/index.js"
@@ -28,10 +28,16 @@
     "no-code"
   ],
   "license": "MIT",
+  "author": "tellet <hello@tellet.com>",
+  "homepage": "https://tellet.com",
+  "bugs": "https://github.com/agentic-company/tellet/issues",
   "repository": {
     "type": "git",
     "url": "https://github.com/agentic-company/tellet"
   },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.80.0",
     "@clack/prompts": "^1.1.0",