redclove 0.1.2 → 0.2.0

package/README.md

@@ -22,4 +22,16 @@ Every block comes with its tests. Run them with `npx vitest run src/blocks --max
 
 Packages your project already lists are left at the version you chose.
 
+## Websites (RedClove Sites)
+
+```bash
+npx redclove sites templates                 # saas, docs, restaurant, portfolio
+npx redclove sites create restaurant my-site # a Next.js site, blocks included
+npx redclove sites pull <site-id>            # bring a site from the editor (REDCLOVE_SITES_KEY)
+npx redclove sites push                      # send content/site.json back
+npx redclove sites deploy                    # upload this folder to Vercel (VERCEL_TOKEN)
+```
+
+`pull` always takes the editor's `content/site.json` (keeping yours as `.bak`) and keeps any other file you changed unless you pass `--overwrite`. `deploy` skips `node_modules`, build output and `.env*` files, and sets the values in `.env.local` as encrypted project settings.
+
 Browse blocks at https://blocks.redclove.space.

package/dist/cli.js

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
 import { createInterface } from "node:readline/promises";
+import { spawnSync } from "node:child_process";
+import { join, relative } from "node:path";
 import { parseArgs } from "node:util";
 import { addBlocks, diffBlock } from "./add.js";
 import { CONFIG_FILE, defaultConfig, readConfig, writeConfig } from "./project.js";
 import { fetchIndex } from "./registry.js";
+import { createFromTemplate, deploySite, listTemplates, pullSite, pushSite } from "./sites.js";
 const HELP = `redclove: add tested backend blocks to your project
 
 Usage
@@ -12,12 +15,23 @@ Usage
   npx redclove diff <block>     compare your copy of a block with the latest one
   npx redclove init             write ${CONFIG_FILE} with where blocks and migrations go
 
+RedClove Sites
+  npx redclove sites templates            list the website templates
+  npx redclove sites create <template> [dir]   start a Next.js site from one
+  npx redclove sites pull [id]            bring a site from the editor into this folder
+  npx redclove sites push                 send content/site.json back to the editor
+  npx redclove sites deploy               deploy this folder to Vercel (needs VERCEL_TOKEN)
+
 Options
   -y, --yes          don't ask; keep files you have changed (with --overwrite, replace them)
       --overwrite    replace files that differ from the block
       --no-install   copy files but don't install packages
       --cwd <dir>    project folder (default: current folder)
       --registry <u> registry URL or folder (default: https://blocks.redclove.space/r)
+      --key <k>      Sites API key (or REDCLOVE_SITES_KEY), for pull and push
+      --site <id>    which site to push to (default: the one this folder was pulled from)
+      --token <t>    Vercel token for deploy (or VERCEL_TOKEN)
+      --preview      deploy a preview instead of production
   -h, --help         show this help
 `;
 const bold = (s) => (process.stdout.isTTY ? `\x1b[1m${s}\x1b[0m` : s);
@@ -31,6 +45,10 @@ async function main() {
             "no-install": { type: "boolean" },
             cwd: { type: "string" },
             registry: { type: "string" },
+            key: { type: "string" },
+            site: { type: "string" },
+            token: { type: "string" },
+            preview: { type: "boolean" },
             help: { type: "boolean", short: "h" },
         },
     });
@@ -92,6 +110,63 @@ async function main() {
             console.log(`Wrote ${CONFIG_FILE}: blocks go in ${config.blocksDir}/, migrations in ${config.migrationsDir}/`);
             return;
         }
+        case "sites": {
+            const [sub, ...rest] = args;
+            const log = (l) => console.log(dim(l));
+            if (sub === "templates") {
+                for (const t of await listTemplates())
+                    console.log(`${bold(t.slug.padEnd(12))} ${t.description}${t.blocks.length ? dim(`  (${t.blocks.join(", ")})`) : ""}`);
+                return;
+            }
+            if (sub === "create") {
+                const [slug, folder] = rest;
+                if (!slug)
+                    throw new UsageError("Usage: npx redclove sites create <template> [folder]");
+                const dir = folder ? join(cwd, folder) : join(cwd, slug);
+                const r = await createFromTemplate(slug, dir);
+                console.log(`Made ${bold(r.name)} in ${dir} (${r.written.length} files).`);
+                if (!values["no-install"]) {
+                    log("$ npm install");
+                    spawnSync("npm", ["install", "--no-audit", "--no-fund"], { cwd: dir, stdio: "inherit", shell: process.platform === "win32" });
+                }
+                console.log(bold("\nNext:") + `\n  cd ${relative(cwd, dir) || "."}\n  npm run dev\n` + dim("  README.md says what's where and how to deploy."));
+                return;
+            }
+            if (sub === "pull") {
+                const interactive = process.stdin.isTTY && !values.yes && !values.overwrite;
+                const rl = interactive ? createInterface({ input: process.stdin, output: process.stdout }) : null;
+                try {
+                    const r = await pullSite(rest[0], cwd, {
+                        key: values.key,
+                        overwrite: values.overwrite ? true : rl ? async (p) => /^y/i.test(await rl.question(`${p} has changes of yours. Replace it? (y/N) `)) : false,
+                    });
+                    for (const f of r.written)
+                        console.log(`  + ${f}`);
+                    for (const f of r.skipped)
+                        console.log(`  ! kept your ${f}`);
+                    if (r.backup)
+                        console.log(dim(`  your previous content is in ${r.backup}`));
+                    console.log(`${r.written.length} written, ${r.unchanged.length} unchanged, ${r.skipped.length} kept.`);
+                }
+                finally {
+                    rl?.close();
+                }
+                return;
+            }
+            if (sub === "push") {
+                const r = await pushSite(cwd, { key: values.key, id: values.site });
+                console.log(`Sent content/site.json to site ${r.id} (now version ${r.version}). Undo it in the editor if you need to.`);
+                return;
+            }
+            if (sub === "deploy") {
+                const r = await deploySite(cwd, { token: values.token, production: !values.preview, log });
+                if (r.readyState !== "READY")
+                    throw new Error(`The build ended as ${r.readyState}. See ${r.inspectorUrl ?? r.url}`);
+                console.log(`${bold("Live:")} ${r.aliases[0] ?? r.url}`);
+                return;
+            }
+            throw new UsageError(`Usage: npx redclove sites <templates|create|pull|push|deploy>\n\n${HELP}`);
+        }
         default:
             throw new UsageError(`Unknown command "${command}".\n\n${HELP}`);
     }

package/dist/hosting.d.ts

@@ -0,0 +1,50 @@
+export type HostFile = {
+    path: string;
+    bytes: Uint8Array;
+};
+type Log = (line: string) => void;
+declare class HostError extends Error {
+    service: string;
+    status: number;
+    constructor(service: string, status: number, message: string);
+}
+export type VercelOptions = {
+    token: string;
+    /** Project name; made if it doesn't exist. */
+    name: string;
+    teamId?: string;
+    /** Environment variables to set on the project before it builds (encrypted, production and preview). */
+    env?: Record<string, string>;
+    production?: boolean;
+    /** Wait for the build to finish. Defaults to true. */
+    wait?: boolean;
+    /** How often to check on the build. */
+    pollMs?: number;
+    log?: Log;
+    fetch?: typeof fetch;
+};
+export type VercelResult = {
+    id: string;
+    url: string;
+    inspectorUrl?: string;
+    readyState: string;
+    aliases: string[];
+};
+/** Uploads the files, creates or reuses the project, sets its settings and deploys it. */
+export declare function deployToVercel(files: HostFile[], opts: VercelOptions): Promise<VercelResult>;
+export type GitHubOptions = {
+    token: string;
+    repo: string;
+    private?: boolean;
+    description?: string;
+    log?: Log;
+    fetch?: typeof fetch;
+};
+export type GitHubResult = {
+    url: string;
+    cloneUrl: string;
+    commit: string;
+};
+/** Makes a new repository and commits every file to it in one commit. */
+export declare function pushToGitHub(files: HostFile[], opts: GitHubOptions): Promise<GitHubResult>;
+export { HostError };

package/dist/hosting.js

@@ -0,0 +1,113 @@
+import { createHash } from "node:crypto";
+class HostError extends Error {
+    service;
+    status;
+    constructor(service, status, message) {
+        super(`${service} answered ${status}: ${message}`);
+        this.service = service;
+        this.status = status;
+    }
+}
+async function call(service, fetchImpl, url, init) {
+    const res = await fetchImpl(url, init);
+    const text = await res.text();
+    let body = null;
+    try {
+        body = text ? JSON.parse(text) : null;
+    }
+    catch {
+        body = text;
+    }
+    if (!res.ok) {
+        const b = body;
+        const message = (typeof b?.error === "object" ? b.error?.message : b?.error) ?? b?.message ?? (typeof body === "string" ? body.slice(0, 200) : "request failed");
+        throw new HostError(service, res.status, message);
+    }
+    return body;
+}
+const VERCEL = "https://api.vercel.com";
+/** Uploads the files, creates or reuses the project, sets its settings and deploys it. */
+export async function deployToVercel(files, opts) {
+    const f = opts.fetch ?? fetch;
+    const log = opts.log ?? (() => { });
+    const q = opts.teamId ? `?teamId=${encodeURIComponent(opts.teamId)}` : "";
+    const auth = { Authorization: `Bearer ${opts.token}` };
+    const name = opts.name.toLowerCase().replace(/[^a-z0-9-]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 100) || "redclove-site";
+    // The project first, so its environment variables are there for the first build.
+    try {
+        await call("Vercel", f, `${VERCEL}/v11/projects${q}`, { method: "POST", headers: { ...auth, "Content-Type": "application/json" }, body: JSON.stringify({ name, framework: "nextjs" }) });
+        log(`Made the Vercel project ${name}`);
+    }
+    catch (e) {
+        if (!(e instanceof HostError && e.status === 409))
+            throw e;
+    }
+    const env = Object.entries(opts.env ?? {}).filter(([, v]) => v);
+    if (env.length) {
+        const sep = q ? "&" : "?";
+        await call("Vercel", f, `${VERCEL}/v10/projects/${encodeURIComponent(name)}/env${q}${sep}upsert=true`, {
+            method: "POST",
+            headers: { ...auth, "Content-Type": "application/json" },
+            body: JSON.stringify(env.map(([key, value]) => ({ key, value, type: "encrypted", target: ["production", "preview"] }))),
+        });
+        log(`Set ${env.map(([k]) => k).join(", ")}`);
+    }
+    const refs = [];
+    let uploaded = 0;
+    for (const file of files) {
+        const sha = createHash("sha1").update(file.bytes).digest("hex");
+        await call("Vercel", f, `${VERCEL}/v2/files${q}`, {
+            method: "POST",
+            headers: { ...auth, "Content-Type": "application/octet-stream", "x-vercel-digest": sha, "Content-Length": String(file.bytes.byteLength) },
+            body: file.bytes,
+        });
+        refs.push({ file: file.path, sha, size: file.bytes.byteLength });
+        if (++uploaded % 25 === 0)
+            log(`Uploaded ${uploaded} of ${files.length} files`);
+    }
+    log(`Uploaded ${files.length} files`);
+    const created = await call("Vercel", f, `${VERCEL}/v13/deployments${q}`, {
+        method: "POST",
+        headers: { ...auth, "Content-Type": "application/json" },
+        body: JSON.stringify({ name, project: name, files: refs, projectSettings: { framework: "nextjs" }, ...(opts.production === false ? {} : { target: "production" }) }),
+    });
+    log(`Building https://${created.url}`);
+    let d = created;
+    if (opts.wait !== false) {
+        const started = Date.now();
+        while (!["READY", "ERROR", "CANCELED"].includes(d.readyState) && Date.now() - started < 15 * 60_000) {
+            await new Promise((r) => setTimeout(r, opts.pollMs ?? 4000));
+            d = await call("Vercel", f, `${VERCEL}/v13/deployments/${created.id}${q}`, { headers: auth });
+        }
+    }
+    return { id: d.id, url: `https://${d.url}`, inspectorUrl: d.inspectorUrl, readyState: d.readyState, aliases: (d.alias ?? []).map((a) => `https://${a}`) };
+}
+const GITHUB = "https://api.github.com";
+/** Makes a new repository and commits every file to it in one commit. */
+export async function pushToGitHub(files, opts) {
+    const f = opts.fetch ?? fetch;
+    const log = opts.log ?? (() => { });
+    const headers = { Authorization: `Bearer ${opts.token}`, Accept: "application/vnd.github+json", "X-GitHub-Api-Version": "2022-11-28", "Content-Type": "application/json" };
+    const gh = (path, method = "GET", body) => call("GitHub", f, `${GITHUB}${path}`, { method, headers, body: body === undefined ? undefined : JSON.stringify(body) });
+    const name = opts.repo.replace(/[^A-Za-z0-9._-]+/g, "-").slice(0, 100);
+    // auto_init gives the repository a first commit; the Git data API can't write to an empty one.
+    const repo = await gh("/user/repos", "POST", {
+        name,
+        private: opts.private ?? true,
+        description: opts.description,
+        auto_init: true,
+    });
+    log(`Made ${repo.html_url}`);
+    const base = await gh(`/repos/${repo.full_name}/git/ref/heads/${repo.default_branch}`);
+    const tree = [];
+    for (const file of files) {
+        const blob = await gh(`/repos/${repo.full_name}/git/blobs`, "POST", { content: Buffer.from(file.bytes).toString("base64"), encoding: "base64" });
+        tree.push({ path: file.path, mode: "100644", type: "blob", sha: blob.sha });
+    }
+    const t = await gh(`/repos/${repo.full_name}/git/trees`, "POST", { tree });
+    const commit = await gh(`/repos/${repo.full_name}/git/commits`, "POST", { message: "The site, from RedClove Sites", tree: t.sha, parents: [base.object.sha] });
+    await gh(`/repos/${repo.full_name}/git/refs/heads/${repo.default_branch}`, "PATCH", { sha: commit.sha, force: true });
+    log(`Committed ${files.length} files`);
+    return { url: repo.html_url, cloneUrl: repo.clone_url, commit: commit.sha };
+}
+export { HostError };

package/dist/index.d.ts

@@ -1,3 +1,5 @@
 export { addBlock, addBlocks, diffBlock, missingPackages, BlockNotFoundError, type AddOptions, type AddResult, type ConflictPolicy, type DiffResult } from "./add.js";
 export { fetchBlock, fetchIndex, registryUrl, DEFAULT_REGISTRY, MIRRORS, type IndexEntry, type RegistryBlock, type EnvVar } from "./registry.js";
 export { readConfig, writeConfig, defaultConfig, detectPackageManager, addCommand, CONFIG_FILE, type Config } from "./project.js";
+export { createFromTemplate, deploySite, editSite, getSections, getSite, listTemplates, projectFiles, pullSite, pushSite, readEnvFile, sitesUrl, DEFAULT_SITES_URL, type PullResult, type SitesOptions, type Template } from "./sites.js";
+export { deployToVercel, pushToGitHub, HostError, type GitHubOptions, type GitHubResult, type HostFile, type VercelOptions, type VercelResult } from "./hosting.js";

package/dist/index.js

@@ -1,3 +1,5 @@
 export { addBlock, addBlocks, diffBlock, missingPackages, BlockNotFoundError } from "./add.js";
 export { fetchBlock, fetchIndex, registryUrl, DEFAULT_REGISTRY, MIRRORS } from "./registry.js";
 export { readConfig, writeConfig, defaultConfig, detectPackageManager, addCommand, CONFIG_FILE } from "./project.js";
+export { createFromTemplate, deploySite, editSite, getSections, getSite, listTemplates, projectFiles, pullSite, pushSite, readEnvFile, sitesUrl, DEFAULT_SITES_URL } from "./sites.js";
+export { deployToVercel, pushToGitHub, HostError } from "./hosting.js";

package/dist/sites.d.ts

@@ -0,0 +1,76 @@
+import { type HostFile, type VercelResult } from "./hosting.js";
+export declare const DEFAULT_SITES_URL = "https://blocks.redclove.space";
+export declare const sitesUrl: (override?: string) => string;
+export type SitesOptions = {
+    url?: string;
+    key?: string;
+    fetch?: typeof fetch;
+    log?: (line: string) => void;
+};
+/** A site's document and version. */
+export declare const getSite: (id: string, opts?: SitesOptions) => Promise<{
+    id: string;
+    name: string;
+    version: number;
+    updatedAt: string;
+    site: Record<string, unknown>;
+}>;
+/** Applies operations to a site. Throws with the server's explanation when one doesn't fit. */
+export declare const editSite: (id: string, ops: unknown[], opts?: SitesOptions) => Promise<{
+    id: string;
+    version: number;
+    applied: unknown[];
+    site: Record<string, unknown>;
+}>;
+/** Every section type with its layouts, sample content and props schema, plus the operation schema. */
+export declare const getSections: (opts?: SitesOptions) => Promise<{
+    sections: unknown[];
+    operation: unknown;
+}>;
+export type Template = {
+    slug: string;
+    name: string;
+    description: string;
+    pages: string[];
+    blocks: string[];
+};
+export declare const listTemplates: (opts?: SitesOptions) => Promise<Template[]>;
+/** Starts a new project in `dir` (which must be empty or missing) from a template. */
+export declare function createFromTemplate(slug: string, dir: string, opts?: SitesOptions): Promise<{
+    name: string;
+    written: string[];
+}>;
+export type PullResult = {
+    written: string[];
+    unchanged: string[];
+    skipped: string[];
+    backup: string | null;
+};
+/**
+ * Brings a site from the editor into `dir`. content/site.json always takes the editor's version (the old one is
+ * kept as content/site.json.bak if it differed). Other files you changed are kept unless overwrite is set.
+ */
+export declare function pullSite(id: string | undefined, dir: string, opts?: SitesOptions & {
+    overwrite?: boolean | ((path: string) => Promise<boolean>);
+}): Promise<PullResult>;
+/** Sends content/site.json to the editor, replacing the site there (it can be undone in the editor). */
+export declare function pushSite(dir: string, opts?: SitesOptions & {
+    id?: string;
+}): Promise<{
+    id: string;
+    version: number;
+}>;
+/** Every file in a project worth deploying: no dependencies, build output, git data or secrets. */
+export declare function projectFiles(dir: string, base?: string): Promise<HostFile[]>;
+/** Reads KEY=value lines from a .env file, if there is one. */
+export declare function readEnvFile(path: string): Promise<Record<string, string>>;
+/** Deploys the project in `dir` to Vercel, with the settings from .env.local. */
+export declare function deploySite(dir: string, opts?: {
+    token?: string;
+    name?: string;
+    teamId?: string;
+    production?: boolean;
+    pollMs?: number;
+    log?: (l: string) => void;
+    fetch?: typeof fetch;
+}): Promise<VercelResult>;

package/dist/sites.js

@@ -0,0 +1,167 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, readdir, writeFile, copyFile } from "node:fs/promises";
+import { dirname, join, relative } from "node:path";
+import { readConfig, writeConfig } from "./project.js";
+import { deployToVercel } from "./hosting.js";
+// `redclove sites …`: start a project from a RedClove Sites template, pull a site from the editor, push content
+// back, and deploy. Talks to the RedClove Sites HTTP API.
+export const DEFAULT_SITES_URL = "https://blocks.redclove.space";
+export const sitesUrl = (override) => (override ?? process.env.REDCLOVE_SITES_URL ?? DEFAULT_SITES_URL).replace(/\/$/, "");
+async function api(opts, path, init = {}) {
+    const key = opts.key ?? process.env.REDCLOVE_SITES_KEY;
+    const res = await (opts.fetch ?? fetch)(`${sitesUrl(opts.url)}${path}`, {
+        ...init,
+        headers: { ...(key ? { Authorization: `Bearer ${key}` } : {}), ...(init.body ? { "Content-Type": "application/json" } : {}), ...(init.headers ?? {}) },
+        signal: AbortSignal.timeout(120_000),
+    });
+    const body = (await res.json().catch(() => ({})));
+    if (!res.ok) {
+        if (res.status === 404 && body.error === "not_found")
+            throw new Error(`Not found at ${sitesUrl(opts.url)}${path}. Check the site id (the last part of its editor address).`);
+        throw new Error(body.message ?? body.error ?? `The server answered ${res.status}`);
+    }
+    return body;
+}
+/** A site's document and version. */
+export const getSite = (id, opts = {}) => api(opts, `/api/sites/${encodeURIComponent(id)}`);
+/** Applies operations to a site. Throws with the server's explanation when one doesn't fit. */
+export const editSite = (id, ops, opts = {}) => api(opts, `/api/sites/${encodeURIComponent(id)}`, { method: "PATCH", body: JSON.stringify({ ops }) });
+/** Every section type with its layouts, sample content and props schema, plus the operation schema. */
+export const getSections = (opts = {}) => api(opts, "/api/sections");
+export const listTemplates = (opts = {}) => api(opts, "/api/templates");
+/** Starts a new project in `dir` (which must be empty or missing) from a template. */
+export async function createFromTemplate(slug, dir, opts = {}) {
+    if (!/^[a-z0-9-]+$/.test(slug))
+        throw new Error(`"${slug}" isn't a template name. Run "redclove sites templates" to see them.`);
+    if (existsSync(dir) && (await readdir(dir)).length)
+        throw new Error(`${dir} isn't empty. Pick a new folder.`);
+    const data = await api(opts, `/api/templates/${slug}/export?format=json`);
+    const written = [];
+    for (const f of data.files)
+        written.push(await writeSafe(dir, f.path, Buffer.from(f.base64, "base64")));
+    return { name: data.name, written };
+}
+async function writeSafe(dir, path, bytes) {
+    const target = join(dir, path);
+    const rel = relative(dir, target);
+    if (!rel || rel.startsWith("..") || /^[/\\]/.test(path))
+        throw new Error(`Refusing to write outside the project: ${path}`);
+    await mkdir(dirname(target), { recursive: true });
+    await writeFile(target, bytes);
+    return rel;
+}
+const sameJson = (a, b) => {
+    try {
+        return JSON.stringify(JSON.parse(Buffer.from(a).toString("utf8"))) === JSON.stringify(JSON.parse(Buffer.from(b).toString("utf8")));
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Brings a site from the editor into `dir`. content/site.json always takes the editor's version (the old one is
+ * kept as content/site.json.bak if it differed). Other files you changed are kept unless overwrite is set.
+ */
+export async function pullSite(id, dir, opts = {}) {
+    const config = await readConfig(dir);
+    const siteId = id ?? config?.site?.id;
+    if (!siteId)
+        throw new Error('Which site? Pass its id ("redclove sites pull <id>"), or run this in a folder you pulled before.');
+    const data = await api({ ...opts, url: opts.url ?? config?.site?.url }, `/api/sites/${encodeURIComponent(siteId)}/export?format=json`);
+    const result = { written: [], unchanged: [], skipped: [], backup: null };
+    for (const f of data.files) {
+        const bytes = Buffer.from(f.base64, "base64");
+        const target = join(dir, f.path);
+        if (f.path === "redclove.json" && config) {
+            // Keep the project's own record of blocks; just note which site it came from.
+            const incoming = JSON.parse(bytes.toString("utf8"));
+            await writeConfig(dir, { ...config, blocks: { ...incoming.blocks, ...config.blocks }, ...{ site: incoming.site } });
+            result.written.push(f.path);
+            continue;
+        }
+        if (existsSync(target)) {
+            const current = await readFile(target);
+            if (current.equals(bytes)) {
+                result.unchanged.push(f.path);
+                continue;
+            }
+            if (f.path === "content/site.json") {
+                if (sameJson(current, bytes)) {
+                    result.unchanged.push(f.path);
+                    continue;
+                }
+                await copyFile(target, `${target}.bak`);
+                result.backup = "content/site.json.bak";
+            }
+            else {
+                const replace = typeof opts.overwrite === "function" ? await opts.overwrite(f.path) : !!opts.overwrite;
+                if (!replace) {
+                    result.skipped.push(f.path);
+                    continue;
+                }
+            }
+        }
+        result.written.push(await writeSafe(dir, f.path, bytes));
+    }
+    return result;
+}
+/** Sends content/site.json to the editor, replacing the site there (it can be undone in the editor). */
+export async function pushSite(dir, opts = {}) {
+    const config = (await readConfig(dir));
+    const id = opts.id ?? config?.site?.id;
+    if (!id)
+        throw new Error("This folder doesn't say which site it is. Pass --site <id>.");
+    const site = JSON.parse(await readFile(join(dir, "content", "site.json"), "utf8"));
+    const res = await api({ ...opts, url: opts.url ?? config?.site?.url }, `/api/sites/${encodeURIComponent(id)}`, {
+        method: "PATCH",
+        body: JSON.stringify({ ops: [{ op: "replace_site", site }] }),
+    });
+    return { id, version: res.version };
+}
+const SKIP = /^(node_modules|\.next|\.git|\.vercel|out|coverage)$|^\.env(?!\.example$)|\.tsbuildinfo$|\.bak$/;
+/** Every file in a project worth deploying: no dependencies, build output, git data or secrets. */
+export async function projectFiles(dir, base = dir) {
+    const out = [];
+    for (const e of await readdir(dir, { withFileTypes: true })) {
+        if (SKIP.test(e.name))
+            continue;
+        const p = join(dir, e.name);
+        if (e.isDirectory())
+            out.push(...(await projectFiles(p, base)));
+        else if (e.isFile())
+            out.push({ path: relative(base, p).split("\\").join("/"), bytes: new Uint8Array(await readFile(p)) });
+    }
+    return out;
+}
+/** Reads KEY=value lines from a .env file, if there is one. */
+export async function readEnvFile(path) {
+    if (!existsSync(path))
+        return {};
+    const out = {};
+    for (const line of (await readFile(path, "utf8")).split(/\r?\n/)) {
+        const m = /^\s*([A-Z_][A-Z0-9_]*)\s*=\s*(.*?)\s*$/.exec(line);
+        if (m)
+            out[m[1]] = m[2].replace(/^(["'])(.*)\1$/, "$2");
+    }
+    return out;
+}
+/** Deploys the project in `dir` to Vercel, with the settings from .env.local. */
+export async function deploySite(dir, opts = {}) {
+    const token = opts.token ?? process.env.VERCEL_TOKEN;
+    if (!token)
+        throw new Error("Set VERCEL_TOKEN (make one at https://vercel.com/account/tokens), or pass --token.");
+    if (!existsSync(join(dir, "package.json")))
+        throw new Error(`${dir} has no package.json. Run this in the site's folder.`);
+    const pkg = JSON.parse(await readFile(join(dir, "package.json"), "utf8"));
+    const env = await readEnvFile(join(dir, ".env.local"));
+    return deployToVercel(await projectFiles(dir), {
+        token,
+        name: opts.name ?? pkg.name,
+        teamId: opts.teamId ?? process.env.VERCEL_TEAM_ID,
+        env,
+        production: opts.production,
+        pollMs: opts.pollMs,
+        log: opts.log,
+        fetch: opts.fetch,
+    });
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "redclove",
-  "version": "0.1.2",
-  "description": "Add tested backend blocks (auth, payments, uploads…) to your project: npx redclove add auth",
+  "version": "0.2.0",
+  "description": "Add tested backend blocks (auth, payments, uploads…) to your project, and start, pull and deploy RedClove Sites: npx redclove add auth",
   "license": "MIT",
   "type": "module",
   "bin": { "redclove": "dist/cli.js" },