@waniwani/kit 0.1.4 → 0.1.5

package/README.md

@@ -529,6 +529,54 @@ flowchart LR
 project carrying a `vercel.json`, which is what lets `vercel deploy` inside it
 work with no special support.
 
+### Deploying is a git push
+
+`waniwani build` writes a Vercel Build Output tree inside `.waniwani/`: the
+bundled function, the static assets, the routing config. A git-connected project
+builds that tree itself on push, and the first build writes the config it needs
+into the app repo:
+
+```json
+// vercel.json, generated once, yours to edit afterwards
+{
+  "framework": null,
+  "buildCommand": "waniwani build && rm -rf .vercel/output && cp -R .waniwani/.vercel/output .vercel/output",
+  "routes": [{ "src": "/api(/.*)?", "dest": "/mcp" }]
+}
+```
+
+Each line answers something Vercel would otherwise get wrong.
+
+`framework: null` stops the project's preset from hunting for a dependency the
+repo does not have, which is what produces `No Next.js version detected` on a
+repo holding no framework at all.
+
+The `buildCommand` moves the tree from `.waniwani/`, which is gitignored and
+absent from the clone, up to the one path where Vercel adopts the Build Output
+API and serves the function as built.
+
+The `routes` entry exists because Vercel reserves a root `api/` directory: it
+compiles every file under one into a serverless function of its own, and an
+endpoint module is not a Vercel handler. That entry is emitted ahead of Vercel's
+filesystem layer, so `/api/*` reaches the server the kit built and the functions
+Vercel made are never routed to. Deleting the directory during the build is not
+an alternative, since the file list is read before the build command runs:
+
+```
+Error: File not found: /vercel/path0/api/cal/book.ts
+```
+
+Deploying without a build works too, once `build` has run:
+
+```bash
+cd .waniwani && vercel deploy --prebuilt
+```
+
+Environment variables live on the platform for both, since `.env` is read from
+disk and a hosted build has no such file. A project that sets its variables for
+production alone gets previews with none, which for an app whose flow reads
+`WANIWANI_API_KEY` at import time means a function that fails to boot.
+
 ### Secrets live in the app's .env
 
 `.env` and `.env.local` sit next to `waniwani.config.ts`, and every command reads

package/cli/codegen.mjs

@@ -875,6 +875,51 @@ function readProvenance(root) {
 	}
 }
 
+/**
+ * What a git-connected Vercel project needs at the app root, written there when
+ * the app has none.
+ *
+ * The build output lands in `.waniwani/`, which is gitignored and absent from
+ * the clone, so a hosted build has to run the kit itself and move the tree to
+ * the one path where Vercel adopts the Build Output API. Every line here is
+ * about this kit's own layout, which is why the file is generated rather than
+ * taken from the template: the template knows nothing about `waniwani build` or
+ * `.waniwani/`.
+ *
+ * The `routes` entry is the part that is not obvious. Vercel reserves a root
+ * `api/` directory and compiles every file under it into a serverless function
+ * of its own, which for an app folder means one broken function per endpoint
+ * (`defineEndpoint({ ... })` is an object, not a Vercel handler) sitting in the
+ * filesystem layer ahead of the server that actually serves them. A legacy
+ * `routes` entry is emitted before that layer, so `/api/*` reaches the kit's
+ * function and Vercel's own are never routed to. There is no way to stop it
+ * building them: it reads the file list before the build command runs, so a
+ * build that deletes the directory fails with `File not found`, and
+ * `outputDirectory` does not suppress it either.
+ */
+const VERCEL_JSON = {
+	$schema: "https://openapi.vercel.sh/vercel.json",
+	// Otherwise the project's framework preset decides, and a preset looking for a
+	// dependency an app folder does not have fails the build outright.
+	framework: null,
+	buildCommand:
+		"waniwani build && rm -rf .vercel/output && cp -R .waniwani/.vercel/output .vercel/output",
+	// Ahead of Vercel's filesystem layer, which is where its own api/ functions sit.
+	routes: [{ src: "/api(/.*)?", dest: "/mcp" }],
+};
+
+/**
+ * @returns true when the file was written, for the CLI to report
+ */
+function ensureVercelJson(appRoot) {
+	const file = join(appRoot, "vercel.json");
+	// An app that has edited its own deploy config keeps it. Overwriting would
+	// throw away a `maxDuration`, a region, or a cron someone needed.
+	if (existsSync(file)) return false;
+	writeFileSync(file, `${JSON.stringify(VERCEL_JSON, null, 2)}\n`);
+	return true;
+}
+
 /** Keep `.waniwani/` out of the app repo, the way `.next/` is kept out. */
 function ignoreBuildOutput(appRoot) {
 	const file = join(appRoot, ".gitignore");
@@ -1055,11 +1100,23 @@ export function generate(app, { template, layout: layoutName = "build", outDir }
 		)}\n`,
 	);
 
+	let vercelJson = false;
 	if (layoutName === "build") {
 		// A .gitignore inside the output would stop `vercel deploy` uploading
 		// anything, so the ignore goes in the app repo instead.
 		ignoreBuildOutput(app.root);
+		// Same reasoning for the deploy config: what Vercel reads on a git build is
+		// the app repo's root, not the output directory.
+		vercelJson = ensureVercelJson(app.root);
 	}
 
-	return { outDir: root, written, overrides, fromTemplate, moved, manifest: Boolean(manifest) };
+	return {
+		outDir: root,
+		written,
+		overrides,
+		fromTemplate,
+		moved,
+		vercelJson,
+		manifest: Boolean(manifest),
+	};
 }

package/cli/index.mjs

@@ -143,7 +143,12 @@ async function prepare(appRoot, flags, { quiet = false } = {}) {
 		console.log(`${yellow("!")} ${dim("GitHub unreachable — using the cached template")}`);
 	}
 
-	const { outDir, overrides, fromTemplate, manifest } = generate(app, { template });
+	const { outDir, overrides, fromTemplate, manifest, vercelJson } = generate(app, { template });
+	// Written into the app's own repo rather than the output, so it is worth a
+	// line even outside debug: it is a tracked file that appeared.
+	if (!quiet && vercelJson) {
+		console.log(`${green("+")} ${bold("vercel.json")} ${dim("— deploy config for a git-connected project")}`);
+	}
 	if (!quiet && DEBUG) {
 		console.log(
 			`${dim(`${fromTemplate.length} files copied`)} ${dim(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@waniwani/kit",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Build an MCP app as a folder: tools, widgets and flows, with one CLI and one shared server runtime.",
   "type": "module",
   "bin": {