create-smoodly-app 0.0.50 → 0.0.52

package/README.md

@@ -2,9 +2,9 @@
 
     npx create-smoodly-app my-site
 
-A fresh Astro or Next.js site with the Smoodly admin mounted at `/admin`, a
-Supabase project holding the schema, `.env` (Astro) or `.env.local` (Next)
-written, and a first editor who can sign in.
+A fresh Astro or Next.js site with the Smoodly admin mounted at `/admin`,
+`.env` (Astro) or `.env.local` (Next) written with a space's three values,
+the site's schema pushed to the space and the starter content seeded.
 
 ## What it asks
 
@@ -18,31 +18,23 @@ written, and a first editor who can sign in.
    gets the next-intl layout: the site under `app/[locale]/`, `i18n/`,
    `proxy.ts`, translated URLs per locale; Astro gets its own i18n config
    (`astro.config.ts` and `src/smoodly/config.ts`). Flag: `--locales en,fi`.
-4. Where content lives: a **local Supabase stack** (`supabase init` +
-   `supabase start` inside the app, with the services Smoodly never uses
-   excluded — the image proxy, edge functions, analytics, the pooler —
-   so the stack stays small beside any other you run; needs
-   the Supabase CLI and Docker; when
-   another project holds the default `543xx` ports the new one moves to the
-   next free block, `553xx` and so on, and says so) or a
-   **hosted project** (URL, publishable key, secret key; then an offer to
-   `supabase link --project-ref <ref>` + `supabase db push`, the ref taken
-   from the URL so the CLI never opens its project picker). The URL may be
-   pasted without `https://`; anything that is not an http(s) URL is refused
-   before any step runs. A custom domain has no ref, so the link is not
-   offered and the two commands are printed instead. Either way the
-   project is Smoodly's own: its tables are created unprefixed in `public`,
-   so an app that keeps its own tables in Supabase gives them a project of
-   their own, or takes Smoodly Cloud for content (DESIGN.md §1).
-5. The first editor: pick an existing Auth user or create one (email +
-   password). The `members` row is written with role `admin`, the email
-   beside the id.
-   If `@` does not appear when you type it (macOS, `@` on Option+2 with the
-   terminal's "Option as Meta" setting on), paste the address or pass
-   `--editor-email`.
+4. **Starter**: Lorem Co. (a tour of every feature, the default) or blank.
+   Flag: `--starter lorem|blank`.
+5. **The space's values**: create a project at smoodly.io, open its preview
+   space and paste the space id (`sp_…`), the secret key (`sk_…`, asked
+   hidden) and the publishable key (`pk_…`). A key of the wrong kind is
+   refused at its prompt. Flags: `--space`, `--secret-key`,
+   `--publishable-key`; a value cannot be defaulted, so `--yes` still asks,
+   and a run with no terminal and no flags names the three flags.
 
-Every prompt has a flag, so CI can run it: `--framework astro|next`, `--supabase local|hosted`, `--locales`,
-`--url`, `--publishable-key`, `--secret-key`, `--editor-email` (password from
-`SMOODLY_EDITOR_PASSWORD`), `--skip-link`, `--yes`. `--help` lists them.
-A hidden `--smoodly-dep <spec>` overrides the `smoodly` dependency written into
-`package.json`; CI points it at the packed tarball.
+Then it installs, writes the env file, runs `npx smoodly push` (the schema
+to the space), `npm run seed` (the starter content through the API) and
+commits. A failed push or seed keeps the folder and prints the command that
+finishes it; a failed install removes the folder.
+
+Every prompt has a flag, so CI can run it: `--framework`, `--locales`,
+`--starter`, `--space`, `--secret-key`, `--publishable-key`, `--yes`.
+`--help` lists them. Hidden flags for the repo's loop and CI:
+`--api-url <url>` writes `SMOODLY_API_URL` (another service than
+Smoodly's), and `--smoodly-dep <spec>` overrides the `smoodly`
+dependency written into `package.json`; CI points it at the packed tarball.

package/dist/index.js

@@ -3,7 +3,7 @@
 // src/index.ts
 import * as p2 from "@clack/prompts";
 import { existsSync } from "node:fs";
-import { readdir as readdir2, readFile as readFile2, rm, writeFile as writeFile2 } from "node:fs/promises";
+import { readdir as readdir2, rm, writeFile as writeFile2 } from "node:fs/promises";
 import { join as join3, relative } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
@@ -24,25 +24,19 @@ function parseFlags(argv) {
     args: argv,
     allowPositionals: true,
     options: {
-      supabase: { type: "string" },
-      url: { type: "string" },
-      "publishable-key": { type: "string" },
+      space: { type: "string" },
       "secret-key": { type: "string" },
-      "editor-email": { type: "string" },
+      "publishable-key": { type: "string" },
+      "api-url": { type: "string" },
       "smoodly-dep": { type: "string" },
       locales: { type: "string" },
       starter: { type: "string" },
       framework: { type: "string" },
-      "skip-link": { type: "boolean", default: false },
       yes: { type: "boolean", short: "y", default: false },
       help: { type: "boolean", short: "h", default: false }
     }
   });
   if (positionals.length > 1) throw new Error("Only one project name is accepted.");
-  const supabase = values.supabase;
-  if (supabase !== void 0 && supabase !== "local" && supabase !== "hosted") {
-    throw new Error(`--supabase must be "local" or "hosted", got "${supabase}"`);
-  }
   const starter = values.starter;
   if (starter !== void 0 && starter !== "lorem" && starter !== "blank") {
     throw new Error(`--starter must be "lorem" or "blank", got "${starter}"`);
@@ -53,12 +47,10 @@ function parseFlags(argv) {
   }
   return {
     name: positionals[0],
-    supabase,
-    url: values.url,
-    publishableKey: values["publishable-key"],
+    space: values.space,
     secretKey: values["secret-key"],
-    editorEmail: values["editor-email"],
-    skipLink: values["skip-link"] ?? false,
+    publishableKey: values["publishable-key"],
+    apiUrl: values["api-url"],
     yes: values.yes ?? false,
     help: values.help ?? false,
     smoodlyDep: values["smoodly-dep"],
@@ -76,61 +68,22 @@ Usage: npx create-smoodly-app [folder] [options]
 
 Options:
   --framework astro|next    The framework (asked when omitted; astro is the default)
-  --supabase local|hosted   Where content lives (asked when omitted; local needs the Supabase CLI)
   --locales <a,b,\u2026>         Multilingual: the locales, first is the default (Astro i18n or next-intl; omitted = one language)
   --starter lorem|blank     lorem: the Lorem Co. tour of every feature (default); blank: one of each, for building your own
-  --url <url>               Hosted: the Supabase project URL
-  --publishable-key <key>   Hosted: the anon / publishable key
-  --secret-key <key>        Hosted: the service-role / secret key
-  --editor-email <email>    The first editor (password from SMOODLY_EDITOR_PASSWORD)
-  --skip-link               Hosted: do not run supabase link / db push
-  -y, --yes                 Accept every default
+  --space <id>              The space's id (sp_\u2026)
+  --secret-key <key>        The space's secret key (sk_\u2026)
+  --publishable-key <key>   The space's publishable key (pk_\u2026)
+                            The three come from your project at smoodly.io: open its preview space and copy them.
+  -y, --yes                 Accept every default (the space's values are still asked when not passed)
   -h, --help                This text
 `;
 
-// src/editor.ts
-import { createClient } from "@supabase/supabase-js";
-async function ensureEditor(client, ask) {
-  const existing = await client.listUsers();
-  const choice = await ask(existing);
-  const user = choice.kind === "pick" ? choice.user : await client.createUser(choice.email, choice.password);
-  await client.upsertEditor(user.id, user.email, "admin");
-  return user;
-}
-function clientFor(keys) {
-  const secret = keys.secretKey.startsWith("sb_secret_");
-  return createClient(keys.url, secret ? keys.secretKey : keys.publishableKey, {
-    global: { headers: secret ? {} : { Authorization: `Bearer ${keys.secretKey}` } },
-    auth: { persistSession: false, autoRefreshToken: false }
-  });
-}
-function supabaseEditorClient(keys) {
-  const db = clientFor(keys);
-  const fail = (what, message) => new Error(`${what}: ${message}`);
-  return {
-    async listUsers() {
-      const res = await db.auth.admin.listUsers({ perPage: 200 });
-      if (res.error) throw fail("listing Auth users", res.error.message);
-      return res.data.users.map((u) => ({ id: u.id, email: u.email ?? null }));
-    },
-    async createUser(email, password2) {
-      const res = await db.auth.admin.createUser({ email, password: password2, email_confirm: true });
-      if (res.error) throw fail("creating the Auth user", res.error.message);
-      return { id: res.data.user.id, email: res.data.user.email ?? null };
-    },
-    async upsertEditor(userId, email, role) {
-      const res = await db.from("members").upsert({ user_id: userId, email, role }, { onConflict: "space_id,user_id" });
-      if (res.error) throw fail("inserting the members row", res.error.message);
-    }
-  };
-}
-
 // src/exec.ts
 import { spawn } from "node:child_process";
 var exec = (cmd, args, opts) => new Promise((resolve3, reject) => {
   const child = spawn(cmd, args, {
     cwd: opts.cwd,
-    stdio: [opts.stdin ?? "inherit", opts.capture ? "pipe" : "inherit", "inherit"],
+    stdio: ["inherit", opts.capture ? "pipe" : "inherit", "inherit"],
     shell: process.platform === "win32"
   });
   let stdout = "";
@@ -141,72 +94,34 @@ var exec = (cmd, args, opts) => new Promise((resolve3, reject) => {
     (code) => code === 0 ? resolve3({ stdout }) : reject(new Error(`\`${cmd} ${args.join(" ")}\` exited with code ${code}`))
   );
 });
-async function hasCommand(cmd, run2, cwd) {
-  try {
-    await run2(cmd, ["--version"], { cwd, capture: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// src/ports-net.ts
-import { createServer } from "node:net";
-function canListen(port2, host) {
-  return new Promise((resolve3) => {
-    const server = createServer();
-    server.once("error", () => resolve3(false));
-    server.listen(port2, host, () => server.close(() => resolve3(true)));
-  });
-}
-async function isPortFree(port2) {
-  return await canListen(port2, "127.0.0.1") && await canListen(port2, "0.0.0.0");
-}
 
 // src/prompts.ts
 import * as p from "@clack/prompts";
 import { resolve as resolve2 } from "node:path";
 
 // src/env.ts
-function renderEnv(keys, siteUrl2 = "http://localhost:3000") {
+var SPACE = "sp_(?:eu_)?[a-z2-7]{20}";
+var KEY = (kind) => new RegExp(`^${kind}_${SPACE}_[a-z2-7]{32}_[a-z2-7]{16}$`);
+var isSpaceId = (v) => new RegExp(`^${SPACE}$`).test(v);
+var isSecretKey = (v) => KEY("sk").test(v);
+var isPublishableKey = (v) => KEY("pk").test(v);
+function renderEnv(values, siteUrl2) {
   return [
-    "# Smoodly, self-host: the content project's values. The live site reads",
-    "# with SMOODLY_URL and SMOODLY_SECRET_KEY; the admin also signs in with",
-    "# SMOODLY_PUBLISHABLE_KEY. SMOODLY_AUTH_URL and SMOODLY_AUTH_KEY default",
-    "# to these \u2014 leave them unset.",
-    `SMOODLY_URL=${keys.url}`,
-    `SMOODLY_SECRET_KEY=${keys.secretKey}`,
-    `SMOODLY_PUBLISHABLE_KEY=${keys.publishableKey}`,
+    "# Smoodly: the space this site reads, from its page at smoodly.io. The",
+    "# secret key stays on the server; replace it from the space page if it",
+    "# ever leaks.",
+    `SMOODLY_SPACE_ID=${values.spaceId}`,
+    `SMOODLY_SECRET_KEY=${values.secretKey}`,
+    `SMOODLY_PUBLISHABLE_KEY=${values.publishableKey}`,
+    ...values.apiUrl ? [`SMOODLY_API_URL=${values.apiUrl}`] : [],
     "",
-    "# The site's own address: absolute hreflang and social URLs. Set it to",
-    "# the production URL where you deploy.",
+    "# The site's own address: absolute links in the page head, and the",
+    "# address the schema push gives the space. Set it to the production URL",
+    "# where you deploy.",
     `SITE_URL=${siteUrl2}`,
     ""
   ].join("\n");
 }
-function normalizeProjectUrl(input) {
-  const raw = input.trim();
-  if (!raw) return null;
-  const withScheme = /^[a-z][a-z0-9+.-]*:\/\//i.test(raw) ? raw : `https://${raw}`;
-  try {
-    const url = new URL(withScheme);
-    if (url.protocol !== "http:" && url.protocol !== "https:") return null;
-    if (!url.hostname) return null;
-    return url.origin;
-  } catch {
-    return null;
-  }
-}
-function projectRef(url) {
-  let host;
-  try {
-    host = new URL(url).hostname;
-  } catch {
-    return null;
-  }
-  const m = /^([a-z0-9]{20})\.supabase\.(co|in|red)$/.exec(host);
-  return m ? m[1] : null;
-}
 
 // src/scaffold.ts
 import { cp, readdir, readFile, rename, writeFile } from "node:fs/promises";
@@ -313,12 +228,36 @@ async function answer(value) {
   if (p.isCancel(v)) bail("Cancelled.");
   return v;
 }
-async function answerOrThrow(value) {
-  const v = await value;
-  if (p.isCancel(v)) throw new Error("Cancelled.");
-  return v;
-}
-async function resolveAnswers(flags2, ctx, env = process.env) {
+var checkSpaceId = (v) => isSpaceId(v) ? void 0 : "A space id looks like sp_\u2026 \u2014 copy it from the space page.";
+var checkSecretKey = (v) => v.startsWith("pk_") ? "That is the publishable key \u2014 paste the secret key (sk_\u2026)." : isSecretKey(v) ? void 0 : "A secret key looks like sk_sp_\u2026 \u2014 copy it from the space page.";
+var checkPublishableKey = (v) => v.startsWith("sk_") ? "That is the secret key \u2014 it never goes where this one goes; paste the publishable key (pk_\u2026)." : isPublishableKey(v) ? void 0 : "A publishable key looks like pk_sp_\u2026 \u2014 copy it from the space page.";
+function checked(value, check) {
+  const message = check(value);
+  if (message) throw new Error(message);
+}
+function typedValues(flags2) {
+  const spaceId = flags2.space?.trim(), secretKey = flags2.secretKey?.trim(), publishableKey = flags2.publishableKey?.trim();
+  if (spaceId !== void 0) checked(spaceId, checkSpaceId);
+  if (secretKey !== void 0) checked(secretKey, checkSecretKey);
+  if (publishableKey !== void 0) checked(publishableKey, checkPublishableKey);
+  return { spaceId, secretKey, publishableKey };
+}
+async function spaceValues(flags2) {
+  const hidden = flags2.apiUrl ? { apiUrl: flags2.apiUrl } : {};
+  const typed = typedValues(flags2);
+  if (typed.spaceId !== void 0 && typed.secretKey !== void 0 && typed.publishableKey !== void 0) {
+    return { spaceId: typed.spaceId, secretKey: typed.secretKey, publishableKey: typed.publishableKey, ...hidden };
+  }
+  if (!process.stdin.isTTY) throw new Error("smoodly: pass --space, --secret-key and --publishable-key \u2014 the space page at smoodly.io shows them.");
+  p.note("Create a project at smoodly.io and open its preview space; paste its values here.", "Smoodly");
+  const ask = (value) => answer(value).then((v) => v.trim());
+  const spaceId = typed.spaceId ?? await ask(p.text({ message: "Space id", placeholder: "sp_\u2026", validate: (v) => checkSpaceId((v ?? "").trim()) }));
+  const secretKey = typed.secretKey ?? await ask(p.password({ message: "Secret key", validate: (v) => checkSecretKey((v ?? "").trim()) }));
+  const publishableKey = typed.publishableKey ?? await ask(p.text({ message: "Publishable key", placeholder: "pk_\u2026", validate: (v) => checkPublishableKey((v ?? "").trim()) }));
+  return { spaceId, secretKey, publishableKey, ...hidden };
+}
+async function resolveAnswers(flags2, ctx) {
+  typedValues(flags2);
   const folderName = (typed2) => nameFromDir(resolve2(ctx.cwd, typed2));
   const typed = flags2.name ?? await answer(p.text({ message: "Project folder", placeholder: "my-site", validate: (v) => v ? validName(folderName(v)) ?? void 0 : "A folder name or path." }));
   const dir = resolve2(ctx.cwd, typed);
@@ -357,64 +296,8 @@ async function resolveAnswers(flags2, ctx, env = process.env) {
       ]
     })
   ));
-  const supabase = flags2.supabase ?? (flags2.yes ? "local" : await answer(
-    p.select({
-      message: "Where should content live?",
-      options: [
-        { value: "local", label: "Local Supabase stack", hint: "supabase start inside the new app; needs the Supabase CLI and Docker" },
-        { value: "hosted", label: "Hosted Supabase project", hint: "paste the project URL and keys" }
-      ]
-    })
-  ));
-  if (supabase === "local") {
-    if (!ctx.hasSupabaseCli) bail("Local mode needs the Supabase CLI: https://supabase.com/docs/guides/cli (brew install supabase/tap/supabase)");
-    if (flags2.editorEmail && !env.SMOODLY_EDITOR_PASSWORD) throw new Error(`Set SMOODLY_EDITOR_PASSWORD to create ${flags2.editorEmail}.`);
-    return { name, dir, supabase, hasSupabaseCli: true, smoodlyDep: flags2.smoodlyDep, locales, starter, framework };
-  }
-  const badUrl = "Supabase project URL must be an http(s) URL, like https://abcd.supabase.co";
-  const typedUrl = flags2.url ?? await answer(
-    p.text({
-      message: "Supabase project URL",
-      placeholder: "https://abcd.supabase.co",
-      validate: (v) => normalizeProjectUrl(v ?? "") ? void 0 : badUrl
-    })
-  );
-  const url = normalizeProjectUrl(typedUrl);
-  if (!url) throw new Error(`${badUrl} (got "${typedUrl}")`);
-  const publishableKey = flags2.publishableKey ?? await answer(p.text({ message: "Publishable (anon) key" }));
-  const secretKey = flags2.secretKey ?? await answer(p.password({ message: "Secret (service role) key" }));
-  const ref = projectRef(url);
-  if (ctx.hasSupabaseCli && !flags2.skipLink && !ref) {
-    p.log.warn(`No project ref in ${url}; skipping supabase link. Run \`supabase link --project-ref <project-ref>\` and \`supabase db push\` yourself.`);
-  }
-  const linkAndPush = !ctx.hasSupabaseCli ? false : flags2.skipLink || !ref ? false : flags2.yes ? true : await answer(p.confirm({ message: `Link this app to the project and push the migration now? (supabase link --project-ref ${ref}, supabase db push)` }));
-  return { name, dir, supabase, hasSupabaseCli: ctx.hasSupabaseCli, hosted: { keys: { url, publishableKey, secretKey }, linkAndPush }, smoodlyDep: flags2.smoodlyDep, locales, starter, framework };
-}
-function askEditorWith(flags2, env = process.env) {
-  return async (existing) => {
-    if (flags2.editorEmail) {
-      const found = existing.find((u) => u.email === flags2.editorEmail);
-      if (found) return { kind: "pick", user: found };
-      const password3 = env.SMOODLY_EDITOR_PASSWORD;
-      if (!password3) throw new Error(`Set SMOODLY_EDITOR_PASSWORD to create ${flags2.editorEmail}.`);
-      return { kind: "create", email: flags2.editorEmail, password: password3 };
-    }
-    if (existing.length > 0) {
-      const picked = await answerOrThrow(
-        p.select({
-          message: "Who is the first editor?",
-          options: [
-            ...existing.map((u) => ({ value: u.id, label: u.email ?? u.id })),
-            { value: "__new__", label: "Create a new user" }
-          ]
-        })
-      );
-      if (picked !== "__new__") return { kind: "pick", user: existing.find((u) => u.id === picked) };
-    }
-    const email = await answerOrThrow(p.text({ message: "Editor email", validate: (v) => v && v.includes("@") ? void 0 : "An email address" }));
-    const password2 = await answerOrThrow(p.password({ message: "Editor password", validate: (v) => v && v.length >= 8 ? void 0 : "At least 8 characters" }));
-    return { kind: "create", email, password: password2 };
-  };
+  const space = await spaceValues(flags2);
+  return { name, dir, space, smoodlyDep: flags2.smoodlyDep, locales, starter, framework };
 }
 
 // src/run.ts
@@ -425,76 +308,18 @@ function templateName(framework, starter, locales) {
   const base = locales === "intl" ? `${starter}-intl` : starter;
   return framework === "astro" ? `astro-${base}` : base;
 }
-function plan(a) {
-  if (a.supabase === "local" && !a.hasSupabaseCli) {
-    throw new Error("Local mode needs the Supabase CLI: https://supabase.com/docs/guides/cli (brew install supabase/tap/supabase)");
-  }
-  const steps = ["copyTemplate", "install"];
-  if (a.supabase === "local") steps.push("supabaseLocal");
-  else if (a.hasSupabaseCli) {
-    steps.push("supabaseInit");
-    if (a.hosted?.linkAndPush) steps.push("linkAndPush");
-  }
-  steps.push("writeEnv", "ensureEditor", "seed", "gitInit", "finish");
-  return steps;
-}
-
-// src/ports.ts
-var DEFAULT_BASE = 54300;
-var BASES = Array.from({ length: 10 }, (_, i) => DEFAULT_BASE + i * 1e3);
-var PORT_LINE = /^([ \t]*#?[ \t]*[a-z0-9_]*port[ \t]*=[ \t]*)543(\d\d)([ \t]*(?:#.*)?)$/gm;
-var LIVE_PORT_LINE = /^[ \t]*[a-z0-9_]*port[ \t]*=[ \t]*(543\d\d)[ \t]*(?:#.*)?$/gm;
-function blockPorts(toml) {
-  return [...toml.matchAll(LIVE_PORT_LINE)].map((m) => Number(m[1]));
-}
-function shiftBlock(toml, base) {
-  return toml.replace(PORT_LINE, (_m, pre, xx, post) => `${pre}${base + Number(xx)}${post}`);
-}
-async function findFreeBlock(ports, isFree, bases = BASES) {
-  for (const base of bases) {
-    const shifted = ports.map((p3) => base + (p3 - DEFAULT_BASE));
-    let allFree = true;
-    for (const port2 of shifted) {
-      if (!await isFree(port2)) {
-        allFree = false;
-        break;
-      }
-    }
-    if (allFree) return base;
-  }
-  throw new Error(`No free Supabase port block: tried ${bases.join(", ")}. Stop another local Supabase project and run again.`);
-}
-
-// src/supabase-cli.ts
-function parseStatusEnv(output) {
-  const vars = /* @__PURE__ */ new Map();
-  for (const line of output.split("\n")) {
-    const m = /^([A-Z_]+)=(?:"([^"]*)"|(.*))$/.exec(line.trim());
-    if (m) vars.set(m[1], m[2] ?? m[3]);
-  }
-  const url = vars.get("API_URL");
-  const publishableKey = vars.get("ANON_KEY");
-  const secretKey = vars.get("SERVICE_ROLE_KEY");
-  if (!url || !publishableKey || !secretKey) {
-    throw new Error("`supabase status -o env` did not report API_URL, ANON_KEY and SERVICE_ROLE_KEY");
-  }
-  return { url, publishableKey, secretKey };
+function plan(_a) {
+  return ["copyTemplate", "install", "writeEnv", "push", "seed", "gitInit", "finish"];
 }
 
 // src/run.ts
-var LOCAL_START_ARGS = ["start", "-x", "imgproxy,edge-runtime,logflare,vector,supavisor"];
 async function run(answers2, deps) {
-  if (answers2.supabase === "hosted" && !answers2.hosted) {
-    throw new Error("hosted answers need the project's keys");
-  }
   if (!await deps.fs.isEmptyOrMissing(answers2.dir)) {
     throw new Error(`${answers2.dir} exists and is not empty.`);
   }
-  const steps = plan(answers2);
-  const ctx = { keys: answers2.hosted?.keys };
   const cwd = answers2.dir;
   const sh = (cmd, args, extra = {}) => deps.exec(cmd, args, { cwd, ...extra });
-  for (const step of steps) {
+  for (const step of plan(answers2)) {
     try {
       switch (step) {
         case "copyTemplate":
@@ -512,58 +337,24 @@ async function run(answers2, deps) {
           deps.log("Installing dependencies\u2026");
           await sh("npm", ["install"]);
           break;
-        case "gitInit":
-          if (answers2.framework === "next") await deps.agentFiles?.(cwd).catch(() => {
-          });
-          await sh("git", ["init"], { capture: true });
-          await sh("git", ["add", "-A"], { capture: true });
-          await sh("git", ["commit", "-m", "Smoodly site"], { capture: true });
-          break;
-        case "supabaseLocal": {
-          deps.log("Starting the local Supabase stack (first run pulls Docker images)\u2026");
-          await sh("supabase", ["init"], { stdin: "ignore" });
-          const configPath = join2(cwd, "supabase/config.toml");
-          const toml = withoutSeedSql(await deps.fs.readFile(configPath));
-          const ports = blockPorts(toml);
-          const base = await findFreeBlock(ports, deps.isPortFree);
-          await deps.fs.writeFile(configPath, base !== DEFAULT_BASE ? shiftBlock(toml, base) : toml);
-          if (base !== DEFAULT_BASE) {
-            deps.log(`Ports ${DEFAULT_BASE / 100}xx are busy (another Supabase project running?), using ${base / 100}xx.`);
-          }
-          try {
-            await sh("supabase", LOCAL_START_ARGS);
-          } catch (e) {
-            const shifted = ports.map((p3) => base + (p3 - DEFAULT_BASE));
-            const taken = (await Promise.all(shifted.map(deps.isPortFree))).some((free) => !free);
-            if (!taken) throw e;
-            const next = await findFreeBlock(ports, deps.isPortFree);
-            await deps.fs.writeFile(configPath, shiftBlock(toml, next));
-            deps.log(`Ports ${base / 100}xx were taken while starting (another Supabase project?), retrying on ${next / 100}xx.`);
-            await sh("supabase", LOCAL_START_ARGS);
-          }
-          ctx.keys = parseStatusEnv((await sh("supabase", ["status", "-o", "env"], { capture: true })).stdout);
-          break;
-        }
-        case "supabaseInit": {
-          await sh("supabase", ["init"], { stdin: "ignore" });
-          const configPath = join2(cwd, "supabase/config.toml");
-          await deps.fs.writeFile(configPath, withoutSeedSql(await deps.fs.readFile(configPath)));
-          break;
-        }
-        case "linkAndPush":
-          await sh("supabase", linkArgs(answers2));
-          await sh("supabase", ["db", "push"]);
-          break;
         case "writeEnv":
-          await deps.fs.writeFile(join2(cwd, envFile(answers2)), renderEnv(ctx.keys, siteUrl(answers2)));
+          await deps.fs.writeFile(join2(cwd, envFile(answers2)), renderEnv(answers2.space, siteUrl(answers2)));
           break;
-        case "ensureEditor":
-          ctx.editor = await ensureEditor(deps.editorClient(ctx.keys), deps.askEditor);
+        case "push":
+          deps.log("Pushing the site's schema to the space\u2026");
+          await sh("npx", ["smoodly", "push"]);
           break;
         case "seed":
           deps.log("Seeding the starter content\u2026");
           await sh("npm", ["run", "seed"]);
           break;
+        case "gitInit":
+          if (answers2.framework === "next") await deps.agentFiles?.(cwd).catch(() => {
+          });
+          await sh("git", ["init"], { capture: true });
+          await sh("git", ["add", "-A"], { capture: true });
+          await sh("git", ["commit", "-m", "Smoodly site"], { capture: true });
+          break;
         case "finish":
           break;
       }
@@ -577,57 +368,29 @@ async function run(answers2, deps) {
         deps.log(`Skipped the initial git commit (${error}). Commit when you like.`);
         continue;
       }
-      return { ok: false, step, error, fallback: fallbackFor(step, answers2, ctx.keys) };
+      return { ok: false, step, error, fallback: fallbackFor(step, answers2) };
     }
   }
-  return { ok: true, keys: ctx.keys, editor: ctx.editor };
+  return { ok: true };
 }
-var withoutSeedSql = (toml) => toml.replace(/(\[db\.seed\]\n(?:#.*\n)*enabled = )true/, "$1false");
 var envFile = (answers2) => answers2.framework === "astro" ? ".env" : ".env.local";
 var siteUrl = (answers2) => answers2.framework === "astro" ? "http://localhost:4321" : "http://localhost:3000";
-function fallbackFor(step, answers2, keys) {
-  const envLines = keys ? `Write ${answers2.dir}/${envFile(answers2)}:
-
-${renderEnv(keys, siteUrl(answers2)).split("\n").filter((l) => !l.startsWith("#")).join("\n").trimEnd()}` : `Write ${answers2.dir}/${envFile(answers2)} with SMOODLY_URL, SMOODLY_SECRET_KEY and SMOODLY_PUBLISHABLE_KEY (from \`supabase status\`), and SITE_URL=${siteUrl(answers2)}.`;
-  const editorLines = [
-    "Create the first editor, then the starter content:",
-    "",
-    `cd ${answers2.dir} && SMOODLY_ADMIN_PASSWORD=<a password> npx smoodly add-admin <your email>`,
-    `cd ${answers2.dir} && npm run seed`
-  ].join("\n");
+function fallbackFor(step, answers2) {
+  const finish = `cd ${answers2.dir} && npx smoodly push && npm run seed`;
   switch (step) {
-    case "supabaseLocal":
-      return [`cd ${answers2.dir} && supabase ${LOCAL_START_ARGS.join(" ")}`, "", envLines, "", editorLines].join("\n");
-    case "supabaseInit": {
-      const commands = answers2.hosted?.linkAndPush ? [`cd ${answers2.dir} && supabase init && ${linkCommand(answers2)} && supabase db push`] : [`cd ${answers2.dir} && supabase init`, "", `When you are ready: ${linkCommand(answers2)} && supabase db push`];
-      return [...commands, "", envLines, "", editorLines].join("\n");
+    case "writeEnv": {
+      const masked = { ...answers2.space, secretKey: "<the secret key you pasted>", publishableKey: "<the publishable key you pasted>" };
+      const lines = renderEnv(masked, siteUrl(answers2)).split("\n").filter((l) => !l.startsWith("#")).join("\n").replace(/\n{2,}/g, "\n").trim();
+      return [`Write ${answers2.dir}/${envFile(answers2)}:`, "", lines, "", "Then the schema and the starter content:", "", finish].join("\n");
     }
-    case "linkAndPush":
-      return [`cd ${answers2.dir} && ${linkCommand(answers2)} && supabase db push`, "", envLines, "", editorLines].join("\n");
-    case "writeEnv":
-      return [envLines, "", editorLines].join("\n");
-    case "ensureEditor":
-      return [
-        "If the members table is missing, apply the migration first: `supabase db push` (hosted) or `supabase start` (local).",
-        "",
-        editorLines
-      ].join("\n");
+    case "push":
+      return finish;
     case "seed":
       return `cd ${answers2.dir} && npm run seed`;
     default:
       return "";
   }
 }
-function linkArgs(answers2) {
-  const url = answers2.hosted?.keys.url ?? "";
-  const ref = projectRef(url);
-  if (!ref) throw new Error(`no project ref in ${url}; run \`supabase link --project-ref <project-ref>\` yourself`);
-  return ["link", "--project-ref", ref];
-}
-function linkCommand(answers2) {
-  const ref = answers2.hosted ? projectRef(answers2.hosted.keys.url) : null;
-  return `supabase link --project-ref ${ref ?? "<project-ref>"}`;
-}
 
 // src/index.ts
 var TEMPLATE_DIRS = {
@@ -656,20 +419,15 @@ p2.intro("create-smoodly-app");
 var answers;
 var outcome;
 try {
-  const hasSupabaseCli = await hasCommand("supabase", exec, process.cwd());
-  answers = await resolveAnswers(flags, { hasSupabaseCli, cwd: process.cwd() });
+  answers = await resolveAnswers(flags, { cwd: process.cwd() });
   const existed = existsSync(answers.dir);
   outcome = await run(answers, {
     exec,
     templateDirs: TEMPLATE_DIRS,
-    editorClient: supabaseEditorClient,
-    askEditor: askEditorWith(flags),
     log: (line) => p2.log.step(line),
-    isPortFree,
     fs: {
       isEmptyOrMissing,
       scaffold,
-      readFile: (path) => readFile2(path, "utf8"),
       writeFile: (path, text2) => writeFile2(path, text2),
       rm: async (dir) => {
         if (!existed) return rm(dir, { recursive: true, force: true });
@@ -698,7 +456,7 @@ p2.note(
     "",
     answers.starter === "blank" ? `Site:  http://localhost:${port}  (a blank site \u2014 build it in ${answers.framework === "astro" ? "src/sections/, src/components/" : "components/"} and at /admin)` : `Site:  http://localhost:${port}  (the Lorem Co. starter \u2014 edit it at /admin)`,
     `Admin: http://localhost:${port}/admin`,
-    `Editor: ${outcome.editor.email ?? outcome.editor.id}`,
+    `Space: ${answers.space.spaceId}  (editors are invited from the project at smoodly.io)`,
     ...answers.locales ? [`Locales: ${answers.locales.join(", ")} (${answers.framework === "astro" ? "astro.config.ts and src/smoodly/config.ts" : "i18n/routing.ts"})`] : []
   ].join("\n"),
   "Ready"