create-skybridge 0.0.0-dev.fb825da → 0.0.0-dev.fb985cd

package/dist/index.js

@@ -1,215 +1,501 @@
-import { spawnSync } from "node:child_process";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import * as prompts from "@clack/prompts";
+import spawn from "cross-spawn";
 import mri from "mri";
-const defaultProjectName = "skybridge-project";
-// prettier-ignore
-const helpMessage = `\
-Usage: create-skybridge [OPTION]... [DIRECTORY]
+const OUTPUT_TAIL_LINES = 10;
+const DEFAULT_PROJECT_NAME = "skybridge-project";
+const PACKAGE_MANAGERS = ["bun", "deno", "npm", "pnpm", "yarn"];
+const TEMPLATES = ["demo", "blank", "ecom"];
+const REPO = "alpic-ai/skybridge";
+const pkg = JSON.parse(fs.readFileSync(fileURLToPath(new URL("../package.json", import.meta.url)), "utf-8"));
+const version = pkg.version;
+const HELP_MESSAGE = `Usage: skybridge create [path] [options]
 
-Create a new Skybridge project by copying the starter template.
+⛰ Skybridge v${version} - the fullstack framework for building MCP Apps
+
+Arguments:
+  path           Where the project will be created. Prompted when omitted.
 
 Options:
-  -h, --help              show this help message
-  --overwrite             remove existing files in target directory
-  --immediate             install dependencies and start development server
+  --blank           scaffold a minimal project without demo tools and views
+  --ecom            scaffold the ecommerce template (search products, render carousel)
+  --example <name>  scaffold a copy of examples/<name> from the latest Skybridge release
+  --overwrite       remove existing files if target directory is not empty
+  --pm <choice>     package manager to use (choices: ${PACKAGE_MANAGERS.join(", ")}. default to npm when none is provided or infered)
+  --skip-skills     skip installing coding agent skills
+  --start           start dev server
+  --yes             skip prompts and use default values for unprovided options
+  --help            display this help message
 
-Examples:
-  create-skybridge my-app
-  create-skybridge . --overwrite --immediate
-`;
+Non-interactive usage:
+  Mandatory: path argument and --yes option
+  Example: skybridge create my-app --yes`;
+const isTTY = process.stdout.isTTY;
+const _spinner = prompts.spinner();
+const Spinner = {
+    start(msg) {
+        if (!isTTY) {
+            prompts.log.info(msg);
+        }
+        else {
+            _spinner.clear();
+            _spinner.start(msg);
+        }
+    },
+    stop(msg) {
+        if (!isTTY) {
+            prompts.log.success(msg);
+        }
+        else {
+            _spinner.stop(msg);
+        }
+    },
+    error(msg) {
+        if (!isTTY) {
+            prompts.log.error(msg);
+        }
+        else {
+            _spinner.error(msg);
+        }
+    },
+};
 export async function init(args = process.argv.slice(2)) {
     const argv = mri(args, {
-        boolean: ["help", "overwrite", "immediate"],
+        boolean: [
+            "help",
+            "blank",
+            "ecom",
+            "overwrite",
+            "skip-skills",
+            "start",
+            "yes",
+        ],
+        string: ["pm", "example"],
         alias: { h: "help" },
     });
-    const argTargetDir = argv._[0]
-        ? sanitizeTargetDir(String(argv._[0]))
-        : undefined;
-    const argOverwrite = argv.overwrite;
-    const argImmediate = argv.immediate;
-    const help = argv.help;
-    if (help) {
-        console.log(helpMessage);
+    if (argv.help) {
+        console.log(HELP_MESSAGE);
         return;
     }
-    const interactive = process.stdin.isTTY;
-    const cancel = () => prompts.cancel("Operation cancelled");
-    // 1. Get project name and target dir
-    let targetDir = argTargetDir;
+    const { yes } = argv;
+    let targetDir = argv._[0] ? sanitizeTargetDir(String(argv._[0])) : undefined;
+    if (yes && !targetDir) {
+        abort("The target directory is required in non-interactive mode.", "Example: skybridge create my-app --yes");
+    }
+    if (argv.example !== undefined && !/^[\w.-]+$/.test(argv.example)) {
+        abort("--example requires a name, e.g. --example auth-descope.");
+    }
+    if (argv.example && (argv.blank || argv.ecom)) {
+        abort("Cannot combine --example with --blank or --ecom.");
+    }
+    const example = argv.example;
+    let pm = parsePackageManager(argv.pm || "");
+    if (argv.pm && !pm) {
+        abort(`Invalid --pm value "${argv.pm}". Expected one of: ${PACKAGE_MANAGERS.join(", ")}.`);
+    }
+    console.log(); // cosmetic line break
+    prompts.intro(`\x1b[1;36m⛰  Welcome to Skybridge v${version} \x1b[22m- the fullstack framework for building MCP Apps\x1b[0m`);
+    // 1. Target directory
     if (!targetDir) {
-        if (interactive) {
-            const projectName = await prompts.text({
-                message: "Project name:",
-                defaultValue: defaultProjectName,
-                placeholder: defaultProjectName,
-                validate: (value) => {
-                    return value.length === 0 || sanitizeTargetDir(value).length > 0
-                        ? undefined
-                        : "Invalid project name";
-                },
+        const choice = await prompts.text({
+            message: "Project directory:",
+            placeholder: DEFAULT_PROJECT_NAME,
+            defaultValue: DEFAULT_PROJECT_NAME,
+            validate: (value) => !value || sanitizeTargetDir(value).length > 0
+                ? undefined
+                : "Invalid project name",
+        });
+        if (prompts.isCancel(choice)) {
+            return cancel();
+        }
+        targetDir = sanitizeTargetDir(choice);
+    }
+    // 2. Existing-directory handling
+    let downloaded;
+    if (example) {
+        Spinner.start(`Downloading ${example} example`);
+        try {
+            downloaded = await downloadExample(example);
+            Spinner.stop(`Downloaded ${example} example`);
+        }
+        catch (error) {
+            Spinner.error(`Failed to download ${example} example`);
+            abort(error instanceof Error ? error.message : String(error));
+        }
+    }
+    if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
+        if (argv.overwrite) {
+            emptyDir(targetDir);
+        }
+        else if (yes) {
+            prompts.log.error(`Target directory "${targetDir}" is not empty. Use --overwrite to remove existing files.`);
+            process.exit(1);
+        }
+        else {
+            const ok = await prompts.confirm({
+                message: `Target directory "${targetDir}" is not empty. Remove existing files?`,
+                initialValue: true,
             });
-            if (prompts.isCancel(projectName)) {
+            if (prompts.isCancel(ok) || !ok) {
                 return cancel();
             }
-            targetDir = sanitizeTargetDir(projectName);
+            Spinner.start(`Cleaning up ${targetDir}`);
+            emptyDir(targetDir);
+            Spinner.stop(`Cleaned up ${targetDir}`);
         }
-        else {
-            targetDir = defaultProjectName;
+    }
+    // 3. Template
+    let template;
+    if (argv.blank) {
+        template = "blank";
+    }
+    if (argv.ecom) {
+        if (template) {
+            abort("Cannot specify both --blank and --ecom.");
         }
+        template = "ecom";
     }
-    // 2. Handle directory if exist and not empty
-    if (fs.existsSync(targetDir) && !isEmpty(targetDir)) {
-        let overwrite = argOverwrite ? "yes" : undefined;
-        if (!overwrite) {
-            if (interactive) {
-                const res = await prompts.select({
-                    message: (targetDir === "."
-                        ? "Current directory"
-                        : `Target directory "${targetDir}"`) +
-                        ` is not empty. Please choose how to proceed:`,
-                    options: [
-                        {
-                            label: "Cancel operation",
-                            value: "no",
-                        },
-                        {
-                            label: "Remove existing files and continue",
-                            value: "yes",
-                        },
-                    ],
-                });
-                if (prompts.isCancel(res)) {
-                    return cancel();
-                }
-                overwrite = res;
-            }
-            else {
-                overwrite = "no";
-            }
+    if (!template && !example) {
+        if (yes) {
+            template = "demo";
         }
-        switch (overwrite) {
-            case "yes":
-                emptyDir(targetDir);
-                break;
-            case "no":
-                cancel();
-                return;
+        else {
+            const choice = await prompts.select({
+                message: "Choose a template:",
+                options: [
+                    {
+                        value: "demo",
+                        label: "demo",
+                        hint: "starter code with tools and UI",
+                    },
+                    {
+                        value: "blank",
+                        label: "blank",
+                        hint: "minimal boilerplate without tools",
+                    },
+                    {
+                        value: "ecom",
+                        label: "ecom",
+                        hint: "ecommerce template with product search tool and carousel view",
+                    },
+                ],
+                initialValue: "demo",
+            });
+            if (prompts.isCancel(choice)) {
+                return cancel();
+            }
+            template = choice;
         }
     }
-    const root = path.join(process.cwd(), targetDir);
-    // 3. Copy the repository
-    prompts.log.step(`Copying template...`);
+    // 4. Copy template
+    const root = path.resolve(targetDir);
+    const templatesDir = fileURLToPath(new URL("../templates", import.meta.url));
+    const source = downloaded?.source ?? path.join(templatesDir, template ?? "demo");
+    Spinner.start(`Copying ${example ?? template} template`);
     try {
-        const templateDir = fileURLToPath(new URL("../template", import.meta.url));
-        // Copy template to target directory
-        fs.cpSync(templateDir, root, {
+        fs.cpSync(source, root, {
             recursive: true,
             filter: (src) => [".npmrc"].every((file) => !src.endsWith(file)),
         });
-        // Rename _gitignore to .gitignore
-        fs.renameSync(path.join(root, "_gitignore"), path.join(root, ".gitignore"));
-        // Update project name in package.json
-        const name = path.basename(root);
+        const gitignore = path.join(root, ".gitignore");
+        const gitignoreSource = path.join(root, "_gitignore");
+        if (fs.existsSync(gitignoreSource)) {
+            fs.renameSync(gitignoreSource, gitignore);
+        }
+        else if (!fs.existsSync(gitignore)) {
+            fs.copyFileSync(path.join(templatesDir, "demo", "_gitignore"), gitignore);
+        }
+        Spinner.stop(`Copied ${example ?? template} template`);
+    }
+    catch (error) {
+        Spinner.error("Failed to copy template");
+        abort(String(error));
+    }
+    finally {
+        downloaded?.cleanup();
+    }
+    // 5. Set package.json name to the project dir basename
+    try {
         const pkgPath = path.join(root, "package.json");
-        const pkg = fs.readFileSync(pkgPath, "utf-8");
-        const fixed = pkg.replace(/apps-sdk-template/g, name);
-        fs.writeFileSync(pkgPath, fixed);
-        prompts.log.success(`Project created in ${root}`);
+        const projectPkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        projectPkg.name = path.basename(root);
+        fs.writeFileSync(pkgPath, `${JSON.stringify(projectPkg, null, 2)}\n`);
     }
     catch (error) {
-        prompts.log.error("Failed to copy repository");
-        console.error(error);
-        process.exit(1);
+        abort("Failed to update project name in package.json.", String(error));
     }
-    const userAgent = process.env.npm_config_user_agent;
-    const pkgManager = userAgent?.split(" ")[0]?.split("/")[0] || "npm";
-    // 4. Ask about immediate installation
-    let immediate = argImmediate;
-    if (immediate === undefined) {
-        if (interactive) {
-            const immediateResult = await prompts.confirm({
-                message: `Install with ${pkgManager} and start now?`,
+    // Async spawn wrapper so a spinner can keep animating during the subprocess
+    // (cross-spawn.sync would block the event loop). Captures stdout/stderr to
+    // `output` when stdio is "pipe", trimmed to the last OUTPUT_TAIL_LINES lines
+    // — install errors land at the tail, so we keep that and prefix with an
+    // ellipsis when content gets dropped.
+    function spawnAsync(command, args) {
+        return new Promise((resolve) => {
+            let raw = "";
+            const child = spawn(command, args, {
+                stdio: ["ignore", "pipe", "pipe"],
+                cwd: root,
             });
-            if (prompts.isCancel(immediateResult)) {
-                return cancel();
-            }
-            immediate = immediateResult;
+            child.stdout?.on("data", (chunk) => {
+                raw += chunk.toString();
+            });
+            child.stderr?.on("data", (chunk) => {
+                raw += chunk.toString();
+            });
+            const done = (status) => {
+                const tail = [];
+                for (const part of raw.split("\n").reverse()) {
+                    const line = part.trim();
+                    if (!line) {
+                        continue;
+                    }
+                    if (tail.length >= OUTPUT_TAIL_LINES) {
+                        tail.push(`… (truncated, showing last ${OUTPUT_TAIL_LINES} lines)`);
+                        break;
+                    }
+                    tail.push(line);
+                }
+                resolve({ status, output: tail.reverse().join("\n") });
+            };
+            child.on("close", done);
+            child.on("error", () => done(1));
+        });
+    }
+    // 6. Skills install (single Y/n prompt)
+    let installSkills;
+    if (argv["skip-skills"]) {
+        installSkills = false;
+    }
+    else if (yes) {
+        installSkills = true;
+    }
+    else {
+        const choice = await prompts.confirm({
+            message: "Install coding agent skills? (recommended)",
+            initialValue: true,
+        });
+        if (prompts.isCancel(choice)) {
+            return cancel();
+        }
+        installSkills = choice;
+    }
+    if (installSkills) {
+        Spinner.start("Installing coding agent skills");
+        const { status, output } = await spawnAsync("npx", [
+            "--yes",
+            "skills",
+            "add",
+            "alpic-ai/skybridge",
+            "--skill",
+            "chatgpt-plugin-builder",
+            "--agent",
+            "universal",
+            "claude-code",
+            "--copy", // something the symlink fails for some reason
+            "--yes",
+        ]);
+        // skills cli always returns 0 so we look for the success message
+        if (status === 0 && output.includes("Done!")) {
+            Spinner.stop(`Installed coding agent skills`);
         }
         else {
-            immediate = false;
+            Spinner.error(`Failed to install coding agent skills:
+\x1b[2m${output}\x1b[0m`);
+            prompts.log.error("Try manually: `npx skills add alpic-ai/skybridge`.");
         }
     }
-    const installCmd = [pkgManager, "install"];
-    const runCmd = [pkgManager];
-    switch (pkgManager) {
-        case "yarn":
-        case "pnpm":
+    // 7. Package manager — autodetect, prompt only if detection fails (interactive)
+    if (!pm) {
+        pm = detectPackageManager() || "npm";
+    }
+    if (!yes) {
+        const choice = await prompts.select({
+            message: "Choose a package manager:",
+            options: PACKAGE_MANAGERS.map((value) => ({ value })),
+            initialValue: pm,
+        });
+        if (prompts.isCancel(choice)) {
+            return cancel();
+        }
+        pm = choice;
+    }
+    // 8. pnpm ≥10 fails installs unless esbuild's build script is allow-listed
+    if (pm === "pnpm") {
+        fs.writeFileSync(path.join(root, "pnpm-workspace.yaml"), 'packages:\n  - "."\nonlyBuiltDependencies:\n  - esbuild\nallowBuilds:\n  esbuild: true\n');
+    }
+    // 9. Always install dependencies
+    Spinner.start(`Installing dependencies with ${pm}`);
+    const { status, output } = await spawnAsync(pm, ["install"]);
+    if (status === 0) {
+        Spinner.stop(`Installed dependencies with ${pm}`);
+    }
+    else {
+        Spinner.error(`Dependency installation failed:
+\x1b[2m${output}\x1b[0m`);
+        abort(`Try manually: cd ${targetDir} && ${pm} install`);
+    }
+    // 10. Start dev server?
+    let start = false;
+    if (argv.start) {
+        start = true;
+    }
+    else if (!yes) {
+        const choice = await prompts.confirm({
+            message: "Start dev server now?",
+            initialValue: true,
+        });
+        if (prompts.isCancel(choice)) {
+            return cancel();
+        }
+        start = choice;
+    }
+    if (start) {
+        prompts.outro(`Starting dev server in ${targetDir}…`);
+        const devResult = spawn.sync(pm, scriptArgs(pm, "dev"), {
+            stdio: "inherit",
+            cwd: root,
+        });
+        process.exit(devResult.status ?? 0);
+    }
+    prompts.log.success("All set! Next steps:");
+    prompts.log.info(`Start:
+cd ${targetDir}
+${scriptCommand(pm, "dev")}`);
+    prompts.log.info(`Deploy:
+${scriptCommand(pm, "deploy")}`);
+    prompts.outro(`🛟  Need help?
+   Chat: https://discord.alpic.ai
+   Docs: https://docs.skybridge.tech`);
+}
+async function fetchJson(url) {
+    const res = await fetch(url, {
+        headers: { accept: "application/vnd.github+json" },
+    });
+    if (!res.ok) {
+        throw new Error(`GitHub returned ${res.status} for ${url}.`);
+    }
+    return res.json();
+}
+async function downloadExample(name) {
+    const api = `https://api.github.com/repos/${REPO}`;
+    const { tag_name: tag } = await fetchJson(`${api}/releases/latest`);
+    const entries = await fetchJson(`${api}/contents/examples?ref=${tag}`);
+    const available = entries
+        .filter((entry) => entry.type === "dir")
+        .map((entry) => entry.name);
+    if (!available.includes(name)) {
+        throw new Error(`Unknown example "${name}". Available examples:\n  ${available.join("\n  ")}`);
+    }
+    const res = await fetch(`https://codeload.github.com/${REPO}/tar.gz/${tag}`);
+    if (!res.ok) {
+        throw new Error(`GitHub returned ${res.status} while fetching ${REPO}.`);
+    }
+    const archive = Buffer.from(await res.arrayBuffer());
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "skybridge-example-"));
+    const cleanup = () => fs.rmSync(tmp, { recursive: true, force: true });
+    try {
+        const tar = spawn("tar", ["-xz", "-C", tmp], {
+            stdio: ["pipe", "ignore", "pipe"],
+        });
+        let stderr = "";
+        tar.stderr?.on("data", (chunk) => {
+            stderr += chunk.toString();
+        });
+        const exit = new Promise((resolve, reject) => {
+            tar.on("error", (error) => reject(error.code === "ENOENT"
+                ? new Error("`tar` is required to extract the example.")
+                : error));
+            tar.on("close", (status) => status === 0
+                ? resolve()
+                : reject(new Error(`tar exited with ${status}: ${stderr.trim()}`)));
+        });
+        tar.stdin?.on("error", () => { });
+        tar.stdin?.end(archive);
+        await exit;
+        const [extracted] = fs.readdirSync(tmp);
+        if (!extracted) {
+            throw new Error("Downloaded archive is empty.");
+        }
+        return { source: path.join(tmp, extracted, "examples", name), cleanup };
+    }
+    catch (error) {
+        cleanup();
+        throw error;
+    }
+}
+function cancel() {
+    prompts.cancel("Operation cancelled");
+    process.exit(0);
+}
+function abort(...lines) {
+    for (const line of lines) {
+        prompts.log.error(line);
+    }
+    prompts.outro("Aborted");
+    process.exit(1);
+}
+function parsePackageManager(value) {
+    switch (value) {
         case "bun":
-            break;
+            return "bun";
         case "deno":
-            runCmd.push("task");
-            break;
+            return "deno";
+        case "npm":
+            return "npm";
+        case "pnpm":
+            return "pnpm";
+        case "yarn":
+            return "yarn";
         default:
-            runCmd.push("run");
-    }
-    runCmd.push("dev");
-    if (!immediate) {
-        prompts.outro(`Done! Next steps:
-  cd ${targetDir}
-  ${installCmd.join(" ")}
-  ${runCmd.join(" ")}
-`);
-        return;
+            return undefined;
     }
-    prompts.log.step(`Installing dependencies with ${pkgManager}...`);
-    run(installCmd, {
-        stdio: "inherit",
-        cwd: root,
-    });
-    prompts.log.step("Starting dev server...");
-    run(runCmd, {
-        stdio: "inherit",
-        cwd: root,
-    });
 }
-function run([command, ...args], options) {
-    const { status, error } = spawnSync(command, args, options);
-    if (status != null && status > 0) {
-        process.exit(status);
+function detectPackageManager() {
+    const userAgent = process.env.npm_config_user_agent;
+    if (!userAgent) {
+        return undefined;
     }
-    if (error) {
-        console.error(`\n${command} ${args.join(" ")} error!`);
-        console.error(error);
-        process.exit(1);
+    const name = userAgent.split(" ")[0]?.split("/")[0];
+    return parsePackageManager(name);
+}
+function scriptArgs(pm, script) {
+    switch (pm) {
+        case "yarn":
+        case "pnpm":
+        case "bun":
+            return [script];
+        case "deno":
+            return ["task", script];
+        case "npm":
+            return ["run", script];
     }
 }
+function scriptCommand(pm, script) {
+    return [pm, ...scriptArgs(pm, script)].join(" ");
+}
 function sanitizeTargetDir(targetDir) {
-    return (targetDir
-        .trim()
-        // Only keep alphanumeric, dash, underscore, dot, @, /
-        .replace(/[^a-zA-Z0-9\-_.@/]/g, "")
-        // Prevent path traversal
-        .replace(/\.\./g, "")
-        // Collapse multiple slashes
-        .replace(/\/+/g, "/")
-        // Remove leading/trailing slashes
-        .replace(/^\/+|\/+$/g, ""));
+    return targetDir.trim().replace(/\/+$/g, "");
+}
+// Skip user's SPEC.md and IDE/agent preferences (.idea, .claude, etc.)
+function isSkippedEntry(entry) {
+    return ((entry.name.startsWith(".") && entry.isDirectory()) ||
+        entry.name === "SPEC.md");
 }
-function isEmpty(path) {
-    const files = fs.readdirSync(path);
-    return files.length === 0 || (files.length === 1 && files[0] === ".git");
+function isEmpty(dirPath) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    return entries.every(isSkippedEntry);
 }
 function emptyDir(dir) {
     if (!fs.existsSync(dir)) {
         return;
     }
-    for (const file of fs.readdirSync(dir)) {
-        if (file === ".git") {
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (isSkippedEntry(entry)) {
             continue;
         }
-        fs.rmSync(path.resolve(dir, file), { recursive: true, force: true });
+        fs.rmSync(path.join(dir, entry.name), { recursive: true, force: true });
     }
 }