create-stacki 0.0.0-stage → 0.1.48

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Timothy Ricks
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,49 @@
-# Temporary Holding Version
+# create-stacki
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Add Stacki Studio to an existing Astro project without installing the desktop app.
+Requires Node.js 22.19.0 or newer and an Astro project using npm with a lockfile.
+If the project has no npm lockfile yet, run `npm install` in it first.
+
+From your project root:
+
+```sh
+npm create stacki@latest
+```
+
+Or pass a project directory:
+
+```sh
+npm create stacki@latest ./my-site
+```
+
+The installer asks for confirmation, installs `/studio`, checks its types, and builds it before
+activating it. It does not change your website source or root package manifest. Each npm release
+contains a specific Studio source release; commit `/studio` to keep that version with your project.
+Installation needs internet access to download Studio's locked npm dependencies.
+
+Start the local editor from your project root:
+
+```sh
+npm --prefix studio run dev
+```
+
+Follow `studio/docs/cloudflare.md` for hosted editing. To get a prompt for your coding agent:
+
+```sh
+npm create stacki@latest -- --agent
+```
+
+For scripts, explicitly confirm installation with:
+
+```sh
+npm create stacki@latest -- --yes
+```
+
+Existing Studio installations are detected and left untouched. Update through Studio's version
+management when ready; updates replace editor customizations while retaining project configuration
+and runtime state. Website source stays outside that replacement. Save customizations in Git first.
+
+Installation uses `.stacki-studio/` for staging and locking. A failed validation keeps the staging
+folder for diagnosis and does not activate Studio. It can be removed after checking the failure.
+Cloudflare deployment and authentication are separate setup steps; this command does not create
+cloud resources or deploy your site.

package/dist/cli.mjs

@@ -0,0 +1,559 @@
+#!/usr/bin/env node
+
+// studio/scripts/createStacki/cli.ts
+import path3 from "node:path";
+import { createInterface } from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { fileURLToPath } from "node:url";
+
+// studio/vendor/stacki/electron/project/studioInstall.ts
+import { cp, lstat, mkdir, open, readdir, rename, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { spawn } from "node:child_process";
+
+// studio/vendor/stacki/shared/core/limits.ts
+var LIMITS = {
+  /** Nodes in one page tree. A 50k-line page is already a code-view page. */
+  treeNodesMax: 2e4,
+  /** Nesting depth of one page tree. Hand-written markup rarely exceeds 20. */
+  treeDepthMax: 64,
+  /** Length of a tag or component name. */
+  tagNameCharsMax: 128,
+  /** Length of a single attribute name or value. */
+  attrCharsMax: 8192,
+  /** Attributes on one tag. */
+  attrsPerNodeMax: 256,
+  /** Text/comment/raw payload of one node, in UTF-16 code units. */
+  nodeValueCharsMax: 1e6,
+  /** Entries of each kind in a project scan (pages, layouts, components). */
+  scanEntriesMax: 1e4,
+  /** Folders listed by a project scan. */
+  scanFoldersMax: 2e3,
+  /** Props on one component schema. */
+  propSchemaFieldsMax: 512,
+  /** Literal options on one union-typed prop. */
+  propOptionsMax: 256,
+  /** Import declarations in one frontmatter block. */
+  importsMax: 256,
+  /** Length of one IPC payload string field. */
+  ipcFieldCharsMax: 1e7,
+  /** Length of one path crossing a boundary: Windows' extended-length limit. */
+  ipcPathCharsMax: 32768,
+  /** Items in one array or keys in one object crossing a boundary. */
+  ipcItemsMax: 1e5,
+  /** Nesting depth of one structured value crossing a boundary. */
+  ipcDepthMax: 128,
+  /** TextMate highlighting is synchronous CPU work after grammar startup. */
+  syntaxHighlightCharsMax: 1e6,
+  // Editor core (plan §8). The projection reuses treeNodesMax and treeDepthMax:
+  // a projected node is a page-tree node, so one name keeps one meaning.
+  /** Bytes of one source file. Merged up from electron/lib/mainLimits.ts so the
+   * renderer, the actor and the disk readers answer to one number. */
+  sourceBytesMax: 10 * 1024 * 1024,
+  /** Intents accepted by one document actor and not yet terminal. Past this,
+   * submission returns `backpressured`; the persistence layer holds the draft. */
+  intentsPendingMax: 64,
+  /** UTF-8 bytes of every string an intent carries, summed. A code patch or a
+   * `rewrite-text` may rewrite a whole file's content, so the bound is the file
+   * bound itself. */
+  intentPayloadBytesMax: 10 * 1024 * 1024,
+  /** Splices one intent may plan, and sites one multi-span operation may name.
+   * A loop rename in a generated page touches hundreds of sites, not millions. */
+  splicesPerIntentMax: 4096,
+  /** Work units one diff may spend, and each span mapping through it: one unit
+   * is one byte comparison or one frontier cell (shared/engine/diff.ts). A 10 MB file
+   * with a small edit costs about 4·10⁷ — both directions scan it once — so the
+   * bound admits the largest file and refuses quadratic blow-ups. Exhaustion is
+   * a `resource-limit` rejection, never a silent fallback. */
+  diffWorkMax: 5e7,
+  /** Edit distance (bytes deleted plus bytes inserted) one diff searches to.
+   * The frontiers it keeps grow with its square: 2·(D + 1)² 32-bit cells, about
+   * 34 MB at this bound. An external change larger than this, racing a pending
+   * intent, rejects with `resource-limit`; the renderer re-authors against the
+   * refreshed snapshot, where no diff is needed. */
+  diffDistanceMax: 2048,
+  /** Document actors one host keeps (electron/documents/documentActors.ts). An actor
+   * holds only its snapshot between intents, so the least recently used idle
+   * one is dropped past this bound and re-reads the disk on its next intent. */
+  documentActorsMax: 512,
+  /** Snapshot bytes all of one host's actors retain together. Without it, 512
+   * actors could each hold a 10 MB file; past it, idle actors are dropped. */
+  documentBytesRetainedMax: 64 * 1024 * 1024,
+  /** Parses one actor may have in flight: the current read plus one newer. */
+  parseTasksInFlightMax: 2,
+  /** Snapshots one actor retains: the committed one plus the candidate under
+   * verification. Pending intents keep only their authored preconditions. */
+  snapshotsRetainedMax: 2,
+  /** Earlier snapshots a host keeps per actor (step 6): the bytes the renderer
+   * authored an edit against, once the actor's own writes or an outside one
+   * replaced them. The renderer keeps authoring against the page it shows
+   * until a save lands with nothing newer typed, so a run of saves under a
+   * busy keyboard needs as many as the commit log holds. Past either bound,
+   * such an edit is refused, never guessed, and the page asks to be reloaded. */
+  authoredSnapshotsMax: 16,
+  /** Bytes of those earlier snapshots per actor, so sixteen copies of a 10 MB
+   * page never pile up; the oldest go first. */
+  authoredBytesRetainedMax: 16 * 1024 * 1024,
+  /** Commits a host remembers per actor — the bytes before, the bytes after,
+   * the splices between — so an edit authored before the actor's own recent
+   * writes is rebased exactly, without a diff (shared/engine/rebase.ts). */
+  commitLogEntriesMax: 16,
+  /** Undo entries one session keeps (the renderer's history; step 6 moves the
+   * bound here from a literal in App.tsx, where it was already 100). */
+  undoEntriesMax: 100,
+  /** Files one watcher tick may mark dirty. Events coalesce into a set, so the
+   * bound caps a burst like `git checkout`, not the event count. */
+  watcherFilesPerTickMax: 1024,
+  /** Source markers one preview render may carry — one per projected node. The
+   * frame counts the stamps of one render against it too (every rendered copy
+   * of a component stamps once), and the morph reloads past it (step 7). */
+  previewMarkersMax: 2e4,
+  /** Work one canvas patch may spend lining up the old and new renderings: one
+   * unit per cell of the child-list matrices it builds (electron/previewClient/morphClient.ts)
+   * — a list of 2 000 children changed in the middle is 4·10⁶ cells, 16 MB of
+   * Int32. Past it the canvas reloads, and says why, instead of freezing the
+   * editor on a page too big to diff (step 7). */
+  previewMorphWorkMax: 4e6,
+  /** Distinct files one preview render's manifest may name: the page, its
+   * layouts and every component that rendered (shared/page/previewToken.ts). A
+   * render past it has no token, and its events are refused. */
+  previewManifestFilesMax: 512,
+  /** UTF-16 units of one project-relative path in a preview stamp. */
+  previewStampPathCharsMax: 1024,
+  /** Diagnostics one parse-error projection carries, and the length of each. */
+  diagnosticsMax: 64,
+  diagnosticCharsMax: 4096
+};
+
+// studio/vendor/stacki/shared/core/record.ts
+function toRecord(input) {
+  if (typeof input !== "object" || input === null || Array.isArray(input)) {
+    return void 0;
+  }
+  return input;
+}
+
+// studio/vendor/stacki/shared/core/boundary.ts
+var BOUNDARY_LIMITS = {
+  textLengthMax: LIMITS.ipcFieldCharsMax,
+  pathLengthMax: LIMITS.ipcPathCharsMax,
+  itemsMax: LIMITS.ipcItemsMax,
+  depthMax: LIMITS.ipcDepthMax
+};
+function record(input) {
+  const value = toRecord(input);
+  if (!value) {
+    throw new Error("Expected object");
+  }
+  if (Object.keys(value).length > BOUNDARY_LIMITS.itemsMax) {
+    throw new Error("Object exceeds limit");
+  }
+  return value;
+}
+
+// studio/vendor/stacki/shared/ipc/studioValidation.ts
+function string(value, maximum = 1e6) {
+  if (typeof value !== "string" || value.length > maximum) {
+    throw new Error("Invalid string");
+  }
+  return value;
+}
+
+// studio/vendor/stacki/shared/ipc/studioRelease.ts
+var RELEASE_BYTES_MAX = 32e6;
+var RELEASE_FILES_MAX = 1500;
+function releaseVersion(value) {
+  const version = string(value, 40);
+  if (!/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/.test(version)) {
+    throw new Error("Expected an exact stable Stacki version");
+  }
+  return version;
+}
+function retainedPath(file) {
+  const first = file.split("/")[0] ?? "";
+  return [".studio", ".wrangler", "cloudflare", ".studio-state"].includes(first) || /^\.(env|dev\.vars)(\.|$)/.test(first);
+}
+function releasePath(value) {
+  const file = string(value, 500);
+  if (!/^[\w.-]+(?:\/[\w.-]+)*$/.test(file) || file.split("/").some((part) => part === "." || part === "..") || retainedPath(file) || !/^(src|scripts|vendor|docs|templates)\//.test(file) && ![
+    "package.json",
+    "package-lock.json",
+    "Dockerfile",
+    ".dockerignore",
+    ".gitignore",
+    "tsconfig.json",
+    "tsconfig.worker.json",
+    "README.md",
+    "AGENTS.md",
+    "LICENSE"
+  ].includes(file)) {
+    throw new Error("Invalid replaceable Studio file: " + file);
+  }
+  return file;
+}
+function parseRelease(input) {
+  const value = record(input);
+  if (value["format"] !== 1 || !Array.isArray(value["files"]) || value["files"].length === 0 || value["files"].length > RELEASE_FILES_MAX) {
+    throw new Error("Unsupported Studio release");
+  }
+  const version = releaseVersion(value["version"]);
+  const names = /* @__PURE__ */ new Set();
+  let bytes = 0;
+  const files = value["files"].map((input2) => {
+    const file = record(input2);
+    const name = releasePath(file["path"]);
+    if (names.has(name.toLowerCase())) {
+      throw new Error("Duplicate Studio file");
+    }
+    names.add(name.toLowerCase());
+    const content = string(file["content"], 2e6);
+    bytes += new TextEncoder().encode(content).byteLength;
+    if (bytes > RELEASE_BYTES_MAX) {
+      throw new Error("Studio release is too large");
+    }
+    return { path: name, content };
+  });
+  for (const required of [
+    "package.json",
+    "package-lock.json",
+    "Dockerfile",
+    "scripts/build.ts",
+    "src/shared/release.json",
+    "vendor/stacki/LICENSE"
+  ]) {
+    if (!names.has(required.toLowerCase())) {
+      throw new Error("Incomplete Studio release");
+    }
+  }
+  for (const file of files) {
+    if (file.path === "package.json" || file.path === "src/shared/release.json") {
+      if (record(JSON.parse(file.content))["version"] !== version) {
+        throw new Error("Studio release version mismatch");
+      }
+    }
+  }
+  return { format: 1, version, files };
+}
+
+// studio/vendor/stacki/electron/project/studioInstall.ts
+async function writeRelease(directory, release) {
+  for (const file of release.files) {
+    const destination = path.join(directory, file.path);
+    await mkdir(path.dirname(destination), { recursive: true });
+    await writeFile(destination, file.content, { flag: "wx" });
+  }
+}
+async function validateInstallation(directory, project) {
+  for (const args of [
+    ["ci", "--ignore-scripts", "--no-audit", "--no-fund"],
+    ["run", "check"],
+    ["run", "build"]
+  ]) {
+    await new Promise((resolve, reject) => {
+      const child = spawn(process.platform === "win32" ? "npm.cmd" : "npm", args, {
+        cwd: directory,
+        stdio: "inherit",
+        shell: process.platform === "win32",
+        env: { ...process.env, STUDIO_PROJECT_ROOT: project }
+      });
+      const timer = setTimeout(() => child.kill("SIGTERM"), 18e4);
+      child.once("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+      child.once("exit", (code) => {
+        clearTimeout(timer);
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error("Studio validation failed; the existing installation was retained"));
+        }
+      });
+    });
+  }
+}
+function installNewRelease(target, release, validate = validateInstallation) {
+  return installReleaseWithMode(target, release, { mode: "install" }, validate);
+}
+async function installReleaseWithMode(target, release, options, validate) {
+  const directory = path.resolve(target);
+  if (path.basename(directory) !== "studio") {
+    throw new Error("Updates target a project\u2019s studio directory");
+  }
+  const metadata = path.join(path.dirname(directory), ".stacki-studio");
+  await mkdir(metadata, { recursive: true });
+  if ((await lstat(metadata)).isSymbolicLink()) {
+    throw new Error("Update storage must not be a symlink");
+  }
+  await writeFile(path.join(metadata, ".gitignore"), "*\n");
+  const lock = await open(path.join(metadata, "update.lock"), "wx");
+  const identifier = `${release.version}-${randomUUID()}`;
+  const staging = path.join(metadata, "staging-" + identifier);
+  const backup = path.join(metadata, "backup-" + identifier);
+  try {
+    const previous = await lstat(directory).catch((error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    });
+    if (previous && options.mode === "install") {
+      throw new Error("Studio already exists; setup will not replace it");
+    }
+    if (previous && (!previous.isDirectory() || previous.isSymbolicLink())) {
+      throw new Error("Studio must be a real directory");
+    }
+    await mkdir(staging);
+    await writeRelease(staging, release);
+    if (!previous) {
+      await cp(path.join(staging, "templates/cloudflare"), path.join(staging, "cloudflare"), {
+        recursive: true
+      });
+    }
+    await validate(staging, path.dirname(directory));
+    if (previous) {
+      await activate(directory, staging, backup);
+    } else {
+      await rename(staging, directory);
+    }
+    return { version: release.version, backup: previous ? backup : void 0 };
+  } finally {
+    await lock.close();
+    await rm(path.join(metadata, "update.lock"), { force: true });
+  }
+}
+async function activate(directory, staging, backup) {
+  const preserved = (await readdir(directory)).filter(retainedPath);
+  const moved = [];
+  await rename(directory, backup);
+  try {
+    for (const entry of preserved) {
+      await rename(path.join(backup, entry), path.join(staging, entry));
+      moved.push(entry);
+    }
+    await rename(staging, directory);
+  } catch (error) {
+    for (const entry of moved.reverse()) {
+      await rename(path.join(staging, entry), path.join(backup, entry));
+    }
+    await rename(backup, directory);
+    throw error;
+  }
+}
+
+// studio/scripts/createStacki/options.ts
+function parseOptions(args) {
+  if (args.length > 8 || args.some((arg) => arg.length > 4096)) {
+    throw new Error("Too many or oversized arguments");
+  }
+  let directory = ".";
+  let hasDirectory = false;
+  let yes = false;
+  let mode = "install";
+  for (const arg of args) {
+    if (arg === "--yes" || arg === "-y") {
+      yes = true;
+    } else if (arg === "--help" || arg === "-h") {
+      mode = "help";
+    } else if (arg === "--version" || arg === "-v") {
+      mode = "version";
+    } else if (arg === "--agent") {
+      mode = "agent";
+    } else if (arg.startsWith("-")) {
+      throw new Error("Unknown option: " + arg);
+    } else if (hasDirectory) {
+      throw new Error("Specify only one existing project directory");
+    } else {
+      directory = arg;
+      hasDirectory = true;
+    }
+  }
+  return { directory, yes, mode };
+}
+function requireSupportedNode(version) {
+  const parts = /^(\d+)\.(\d+)\.(\d+)$/.exec(version);
+  const major = Number(parts?.[1]);
+  const minor = Number(parts?.[2]);
+  if (!parts || major < 22 || major === 22 && minor < 19) {
+    throw new Error("Stacki Studio needs Node.js 22.19.0 or newer");
+  }
+}
+
+// studio/scripts/createStacki/project.ts
+import { lstat as lstat2, open as open2, realpath } from "node:fs/promises";
+import path2 from "node:path";
+
+// studio/src/shared/validation.ts
+var MAX_SOURCE = 1e6;
+function record2(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("Expected object");
+  }
+  return value;
+}
+function string2(value, maximum = MAX_SOURCE) {
+  if (typeof value !== "string" || value.length > maximum) {
+    throw new Error("Invalid string");
+  }
+  return value;
+}
+
+// studio/scripts/createStacki/project.ts
+async function readJson(file, maximum) {
+  const handle = await open2(file, "r");
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > maximum) {
+      throw new Error("Expected a bounded JSON file: " + file);
+    }
+    return JSON.parse(await handle.readFile("utf8"));
+  } finally {
+    await handle.close();
+  }
+}
+async function projectDirectory(directory) {
+  const project = await realpath(path2.resolve(directory));
+  const manifest = record2(await readJson(path2.join(project, "package.json"), 1e6));
+  const dependencies = record2(manifest["dependencies"] ?? {});
+  const development = record2(manifest["devDependencies"] ?? {});
+  if (typeof dependencies["astro"] !== "string" && typeof development["astro"] !== "string") {
+    throw new Error("Run this from an existing Astro project, or pass its directory");
+  }
+  await requireProjectLock(project);
+  return project;
+}
+async function requireProjectLock(project) {
+  for (const name of ["npm-shrinkwrap.json", "package-lock.json"]) {
+    const file = path2.join(project, name);
+    const exists = await lstat2(file).catch((error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+        return void 0;
+      }
+      throw error;
+    });
+    if (!exists) {
+      continue;
+    }
+    const value = record2(await readJson(file, 8e6));
+    const version = value["lockfileVersion"];
+    if (typeof version === "number" && Number.isSafeInteger(version) && version >= 1) {
+      return;
+    }
+    throw new Error("Invalid npm lockfile. Run npm install in your project before adding Studio");
+  }
+  throw new Error("Studio needs an npm lockfile. Run npm install in your project, then retry");
+}
+async function installedVersion(project) {
+  const target = path2.join(project, "studio");
+  const stat = await lstat2(target).catch((error) => {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return void 0;
+    }
+    throw error;
+  });
+  if (!stat) {
+    return void 0;
+  }
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error("The studio path already exists and cannot be replaced by setup");
+  }
+  try {
+    const manifest = record2(await readJson(path2.join(target, "package.json"), 1e6));
+    if (string2(manifest["name"], 100) !== "@stacki/studio") {
+      throw new Error("Not Stacki Studio");
+    }
+    const release = record2(await readJson(path2.join(target, "src/shared/release.json"), 4096));
+    return releaseVersion(release["version"]);
+  } catch {
+    throw new Error("A studio folder already exists. Setup will not overwrite its contents");
+  }
+}
+
+// studio/scripts/createStacki/cli.ts
+var HELP = `Add Stacki Studio to an existing Astro project.
+
+  npm create stacki@latest [project-directory]
+  npm create stacki@latest -- --yes
+
+Options:
+  --yes, -y      Install without the confirmation prompt
+  --agent       Print a setup prompt for your coding agent; change no files
+  --help, -h    Show this help
+  --version, -v Show the bundled Studio version
+
+Studio is installed in ./studio. Existing installations are never replaced.
+`;
+var AGENT = `Set up Stacki Studio in this existing Astro project.
+If /studio is missing, run npm create stacki@latest -- --yes from the project root.
+If it exists, inspect it first; do not overwrite customizations or update silently.
+Read studio/AGENTS.md, studio/README.md, and studio/docs/cloudflare.md.
+Start the local preview with npm --prefix studio run dev and verify /studio.
+Guide me through GitHub authentication and Cloudflare Containers deployment using
+studio/cloudflare and the documented setup. Ask me for project-specific choices.
+Keep credentials in local secret storage or Cloudflare secrets, never source files.
+Preserve website source. Verify local editing before any deployment.
+Ask for approval before creating paid resources or deploying anything.
+Report external setup that still needs my action. Updates are always opt-in.`;
+async function confirm(project) {
+  if (!stdin.isTTY || !stdout.isTTY) {
+    throw new Error(
+      "Use --yes for a noninteractive installation, or --agent for setup instructions"
+    );
+  }
+  const input = createInterface({ input: stdin, output: stdout });
+  try {
+    const answer = await input.question(
+      `Install Stacki Studio in ${path3.join(project, "studio")}? [y/N] `
+    );
+    return /^(y|yes)$/i.test(answer.trim());
+  } finally {
+    input.close();
+  }
+}
+async function main() {
+  const options = parseOptions(process.argv.slice(2));
+  if (options.mode === "help" || options.mode === "agent") {
+    console.log(options.mode === "help" ? HELP : AGENT);
+    return;
+  }
+  requireSupportedNode(process.versions.node);
+  const release = parseRelease(
+    await readJson(
+      fileURLToPath(new URL("./stacki-studio.json", import.meta.url)),
+      RELEASE_BYTES_MAX
+    )
+  );
+  if (options.mode === "version") {
+    console.log(release.version);
+    return;
+  }
+  const project = await projectDirectory(options.directory);
+  const installed = await installedVersion(project);
+  if (installed) {
+    console.log(`Stacki Studio ${installed} is already installed. No files were changed.`);
+    console.log(
+      "Open Studio to manage its version. Run npm --prefix studio run dev in this project."
+    );
+    return;
+  }
+  console.log(`Stacki Studio ${release.version} \u2014 1/3 Install`);
+  if (!options.yes && !await confirm(project)) {
+    console.log("Cancelled. No files were changed.");
+    return;
+  }
+  console.log("Installing dependencies, checking types, and building Studio\u2026");
+  await installNewRelease(path3.join(project, "studio"), release);
+  console.log(`
+Installed Stacki Studio ${release.version} in ${path3.join(project, "studio")}`);
+  console.log("\n2/3 Local preview\nFrom your project root, run: npm --prefix studio run dev");
+  console.log(
+    "\n3/3 Go live\nFollow studio/docs/cloudflare.md to configure GitHub and Cloudflare."
+  );
+  console.log("For a prompt to give your agent: npm create stacki@latest -- --agent");
+  console.log("Commit /studio to keep this version with your project. Updates are opt-in.");
+}
+void main().catch((error) => {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exitCode = 1;
+});