@waniwani/kit 0.1.1 → 0.1.3

package/README.md

@@ -1,6 +1,6 @@
 # @waniwani/kit
 
-**Build an MCP app as a folder.** You write tools, widgets, flows and docs into
+**Build an MCP app as a folder.** You write tools, widgets and flows into
 a directory, and one CLI turns that directory into a deployable MCP server. Your
 repo holds none of the plumbing: server bootstrap, transport wiring, build
 configuration.
@@ -15,8 +15,7 @@ oney/                          # what you write
 ├── waniwani.config.ts
 ├── tools/check-eligibility.ts
 ├── widgets/select-plan/{widget.ts,ui.tsx}
-├── flows/split-payment.ts
-└── docs/*.md
+└── flows/split-payment.ts
 
 waniwani build                 # → .waniwani/, an ordinary npm project
 ```
@@ -82,9 +81,25 @@ registers them come from the kit.
 
 ## Quickstart
 
-There is no `waniwani init` yet, so the first files go in by hand.
-[examples/oney](https://github.com/WaniWani-AI/kit/blob/main/examples/oney) is this same app finished, if you would rather
-read it than type it.
+```bash
+npx @waniwani/kit init oney
+cd oney && npm run dev
+```
+
+`init` writes a folder that already answers: an app config, one tool, and the
+widget that displays what the tool returned. It installs, and the dev
+server is one command away. `--minimal` scaffolds the config and the tool alone,
+`--name` sets the MCP server name, and running it inside an existing repo merges
+into that repo's `package.json` and `.gitignore` instead of replacing them.
+
+Where the app lands follows the argument. `init oney` creates `oney/`, `init .`
+uses the current folder, and a bare `init` asks for a name and reads the answer
+as both: a name of its own creates `./<name>/`, while the offered default, your
+current folder's name, scaffolds in place.
+
+The rest of this section is what those files hold, written out by hand.
+[examples/oney](https://github.com/WaniWani-AI/kit/blob/main/examples/oney) is the same app finished, if you would rather read
+it than type it.
 
 ```bash
 mkdir oney && cd oney
@@ -235,9 +250,6 @@ oney/
 │       └── ui.tsx              export default function Component()
 ├── flows/
 │   └── split-payment.ts        export default createFlow(...).compile()   ← SDK
-├── docs/
-│   ├── fees.md                 becomes the `search_docs` tool
-│   └── eligibility.md
 └── lib/                        anything else is just modules
 ```
 
@@ -251,7 +263,6 @@ unwired.
 | `tools/<name>.ts` | one MCP tool | `.ts`, `.tsx` and `.mts` are picked up |
 | `widgets/<name>/` | one MCP tool plus a `ui://` resource | needs `widget.ts` and `ui.tsx` |
 | `flows/<name>.ts` | one MCP tool, registered from the SDK unchanged | whatever `.compile()` returns |
-| `docs/*.md` | a single `search_docs` tool over all of them | the first `# heading` becomes the title |
 | anything else | plain modules | the CLI leaves it alone |
 
 The app folder imports `@waniwani/kit`, plus `@waniwani/sdk` when it uses flows,
@@ -392,15 +403,16 @@ letting it sit there doing nothing:
 ## Commands
 
 ```bash
+waniwani init [dir] # scaffold an app folder, install, ready to dev
 waniwani check      # validate the folder
 waniwani dev        # generate + dev server + regenerate on change
 waniwani build      # generate + production build
 waniwani start      # run the production build
-waniwani deploy     # generate + vercel deploy
 waniwani eject [--out dir]   # hand the plumbing over and step out
 ```
 
-Every one of them runs the same four stages before doing its own work.
+`init` writes files and stops there. Every other command runs the same four
+stages before doing its own work.
 
 ```mermaid
 flowchart LR
@@ -409,7 +421,6 @@ flowchart LR
         tools["tools/*.ts"]
         widgets["widgets/&lt;name&gt;/<br/>widget.ts + ui.tsx"]
         flows["flows/*.ts"]
-        docs["docs/*.md"]
     end
 
     subgraph tpl["WaniWani-AI/mcp-distribution-template (public, separate repo)"]
@@ -433,7 +444,7 @@ flowchart LR
     app --> scan --> check --> gen --> out
     runtime -.imported by.-> server
     raw -.fetched at a pinned SHA, copied byte for byte.-> deployfiles
-    out --> deploy["dev · build · start<br/>vercel deploy"]
+    out --> deploy["dev · build · start"]
     app -.waniwani eject.-> ejected["a plain repo<br/><i>no CLI, no @waniwani/kit</i>"]
 ```
 
@@ -513,9 +524,9 @@ under `src/app/`:
 
 ```
 oney/
-├── src/app/{tools,widgets,flows,docs,lib}/   your code, moved
+├── src/app/{tools,widgets,flows,lib}/        your code, moved
 ├── src/_runtime/                             the runtime, vendored as source
-├── src/{server,waniwani,docs}.ts             entry, registration, inlined docs
+├── src/{server,waniwani}.ts                  entry and registration
 ├── src/views/<widget>.tsx                    view entries
 ├── vite.config.ts  vercel.json  alpic.json   bundling and deploy
 ├── Dockerfile  .dockerignore                 container deploy
@@ -545,8 +556,6 @@ What an ejected repo gives up is the generator, and with it:
 - **the build check**, so `showWidget("typo")` becomes a runtime failure again
 - **name-from-filesystem**, so adding a widget means editing `src/waniwani.ts`
   and adding an entry under `src/views/`
-- **docs auto-scan**, since `src/docs.ts` is a snapshot and new `docs/*.md` need
-  hand-wiring
 - **runtime fixes**, since `src/_runtime/` is a fork from the moment it lands
 
 ## Status
@@ -555,12 +564,12 @@ What an ejected repo gives up is the generator, and with it:
 
 - **`@waniwani/cli` owns the `waniwani` bin on npm**, so installing both
   collides.
-- **No `waniwani init`**, so a new app folder starts by hand.
-- **`waniwani deploy` is wired but unrun** against a real Vercel account.
+- **`waniwani init` scaffolds one shape of app**, a tool with the widget that
+  displays it. A flow is not among the files it writes.
+- **Deploying is manual.** `.waniwani/` carries a `vercel.json`, so
+  `vercel deploy` inside it works, but no command wraps that.
 - **`useWidget` does not track yet.** Emitting `widget_render` and click events
   through `useWaniwani` automatically is the next step.
-- **Docs search is a term-match** rather than the hosted KB. Swapping it for
-  `wani.kb.search` when `WANIWANI_API_KEY` is set is a runtime change only.
 
 Template pinning, the CI contract, publishing requirements and the rest of the
 gap list are in [INTERNALS.md](https://github.com/WaniWani-AI/kit/blob/main/INTERNALS.md).

package/cli/codegen.mjs

@@ -201,7 +201,7 @@ const SCRIPT_ADDITIONS = {
  */
 const SCRIPT_REMOVALS = {
 	"kb:ingest": {
-		why: "ingests knowledge-base/, which is the example's; an app's docs are docs/*.md, inlined at build",
+		why: "ingests knowledge-base/, which is the example's; an app has no such folder",
 	},
 };
 
@@ -247,9 +247,7 @@ const NOT_SOURCE = new Set([
 	".skybridge",
 	".vercel",
 	// The repo's own, not the app's. An in-place eject moves what it copies, and
-	// a README that reappears under `src/app/` is a bad surprise. Docs the app
-	// actually serves live in `docs/*.md` and are inlined separately, so nothing
-	// is lost by skipping these at every level.
+	// a README that reappears under `src/app/` is a bad surprise.
 	"README.md",
 	"LICENSE",
 	// Lockfiles describe the repo's install, and the generated package.json is
@@ -268,7 +266,7 @@ const NOT_SOURCE = new Set([
  * tools in it, and reads `src/waniwani.ts` — the one file this generates into
  * the template's tree.
  */
-const GENERATED = ["src/waniwani.ts", "src/docs.ts", "tsconfig.json", ".template.json"];
+const GENERATED = ["src/waniwani.ts", "tsconfig.json", ".template.json"];
 
 /** `select-plan` -> `selectPlan`, for generated identifiers. */
 function camel(name) {
@@ -599,7 +597,6 @@ function generateServerApp(app, layout, { runtime, styleDomains }) {
 		`import { config as loadEnv } from "dotenv";`,
 		`import type { McpServer } from "skybridge/server";`,
 		`import { registerApp as register } from "${runtime.server}";`,
-		app.docs.length > 0 ? `import { docs } from "./docs.js";` : null,
 		`import config from "${from}/waniwani.config.js";`,
 		...app.tools.map((t) => `import tool_${camel(t.name)} from "${from}/tools/${t.name}.js";`),
 		...app.widgets.map(
@@ -630,7 +627,6 @@ export async function registerApp(server: McpServer): Promise<void> {
 		tools: ${list(app.tools.map((t) => `{ name: "${t.name}", def: tool_${camel(t.name)} }`))},
 		widgets: ${list(app.widgets.map((w) => `{ name: "${w.name}", def: widget_${camel(w.name)} }`))},
 		flows: ${list(app.flows.map((f) => `flow_${camel(f.name)}`))},
-		docs: ${app.docs.length > 0 ? "docs" : "[]"},
 		// Read off the template's ${STYLE_ENTRY}, which every view imports.
 		styleDomains: ${list(styleDomains.map((origin) => `"${origin}"`))},
 	});
@@ -638,22 +634,6 @@ export async function registerApp(server: McpServer): Promise<void> {
 `;
 }
 
-/**
- * Docs are inlined into a module rather than read from disk, so they survive a
- * serverless bundle with no filesystem.
- */
-function generateDocs(app, { runtime }) {
-	return `// Generated from docs/*.md.
-import type { DocEntry } from "${runtime.index}";
-
-export const docs: DocEntry[] = ${JSON.stringify(
-		app.docs.map((doc) => ({ slug: doc.slug, title: doc.title, body: doc.body })),
-		null,
-		2,
-	)};
-`;
-}
-
 function generateWidgetShim(widget, layout) {
 	// From `src/views/` up to `src/`, then out to the app's source.
 	const from = `../${basename(layout.appDir)}`;
@@ -740,7 +720,6 @@ function generateBiome(template, layout) {
 				// Generated and vendored code is not the app author's to fix.
 				`!${layout.runtimeDir}/**`,
 				"!src/server.ts",
-				"!src/docs.ts",
 				"!src/views/**",
 				...negative,
 			],
@@ -861,7 +840,7 @@ function assertSeam(template) {
 
 	throw new Error(
 		`the template at ${template.source} never calls ${SEAM.symbol}(), so this app's\n` +
-			`  tools, widgets, flows, and docs would be built and then silently dropped.\n\n` +
+			`  tools, widgets and flows would be built and then silently dropped.\n\n` +
 			`  Add to its ${SEAM.file}:\n\n` +
 			`    import { app, registerApp } from "./waniwani.js";\n\n` +
 			`    const server = new McpServer(\n` +
@@ -1003,10 +982,6 @@ export function generate(app, { template, layout: layoutName = "build", outDir }
 		"src/waniwani.ts",
 		generateServerApp(app, layout, { runtime, styleDomains: templateStyleDomains(template) }),
 	);
-	if (app.docs.length > 0) {
-		emit("src/docs.ts", generateDocs(app, { runtime }));
-	}
-
 	// `src/views/` is shared: the template's own views sit alongside the app's,
 	// so it cannot be wiped. Only the entries a previous build wrote are
 	// removed, which is what clears a widget the app has since deleted.
@@ -1046,9 +1021,14 @@ export function generate(app, { template, layout: layoutName = "build", outDir }
 				sha: template.sha,
 				local: template.local,
 				manifest: manifest ? MANIFEST_FILE : undefined,
-				// What survived to the end: the generated files land on top of
-				// the copy, so the raw list overstates it.
-				files: fromTemplate.filter((file) => existsSync(join(root, file))),
+				// What survived to the end, copied and generated alike. The
+				// copy is the raw list minus whatever a generated file replaced,
+				// and the generated half is here so that a build which stops
+				// emitting one — `src/docs.ts` when docs left the framework —
+				// cleans up the copy the previous build left behind.
+				files: [...new Set([...fromTemplate, ...GENERATED])].filter((file) =>
+					existsSync(join(root, file)),
+				),
 				// Tracked separately because `src/views/` is shared with the
 				// template — the next build needs to know which entries were
 				// ours before it removes any.

package/cli/framework.mjs

@@ -91,7 +91,6 @@ function reword(line) {
  *
  * The framework's own tunnel is one of those lines. No command here asks for it,
  * so what arrives is its offer of one, and the emoji it carries drops the line.
- * A public hostname comes from `waniwani tunnel` instead (see ./tunnel.mjs).
  *
  * Each pattern leads with `\W*` to absorb whatever emoji prefixes the line and
  * ends at `$`, so a rule reads the framework's whole line and can't fire on an

package/cli/index.mjs

@@ -2,12 +2,11 @@
 /**
  * The `waniwani` CLI.
  *
+ *   waniwani init     scaffold a new app folder and install it
  *   waniwani check    validate the app folder
  *   waniwani dev      check, generate, run the dev server, watch for changes
- *   waniwani tunnel   dev, on a public hostname, wired to the playground
  *   waniwani build    check, generate, build for production
  *   waniwani start    run the production build
- *   waniwani deploy   build, then deploy the generated project to Vercel
  *   waniwani eject    write the plumbing into the repo and hand it over
  *
  * Every command scans the app folder, validates it, and generates a complete
@@ -19,20 +18,19 @@ import { spawn } from "node:child_process";
 import { existsSync, readFileSync, watch } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { connectAccount, createClient } from "./account.mjs";
 import { existingPlumbing, generate } from "./codegen.mjs";
-import { banner, bold, dim, endpoint, green, printReport, red, yellow } from "./log.mjs";
+import { init } from "./init.mjs";
+import { banner, bold, dim, green, printReport, red, yellow } from "./log.mjs";
 import { scanApp } from "./scan.mjs";
 import { devFilter, FRAMEWORK_ENV, frameworkBin, loadBuildSteps, runBuildSteps, startFilter } from "./framework.mjs";
 import { DEFAULT_TEMPLATE, describeTemplate, resolveTemplate } from "./template.mjs";
-import { findAvailablePort, isPortAvailable, startNamedTunnel, waitForLocalServer } from "./tunnel.mjs";
 import { validateApp } from "./validate.mjs";
 
 const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
 const PACKAGE_VERSION = JSON.parse(readFileSync(join(PACKAGE_ROOT, "package.json"), "utf-8")).version;
 
 /** The commands a human sits and watches. `check` and `eject` are often scripted. */
-const BANNERED = new Set(["dev", "tunnel", "build", "start", "deploy"]);
+const BANNERED = new Set(["init", "dev", "build", "start"]);
 
 /**
  * Diagnostics about this CLI's own machinery — which template was resolved, how
@@ -67,11 +65,8 @@ function binPath(from) {
  *
  * `shell` is for the framework's build steps, which name their command as one
  * string rather than an argv.
- *
- * `onChild` hands the process back to the caller. `tunnel` keeps working while
- * the dev server runs and has to be able to take it down with it.
  */
-function run(command, args, { cwd, env, shell = false, stdoutFilter, stderrFilter, onChild } = {}) {
+function run(command, args, { cwd, env, shell = false, stdoutFilter, stderrFilter } = {}) {
 	return new Promise((resolvePromise) => {
 		const child = spawn(command, args, {
 			cwd,
@@ -79,7 +74,6 @@ function run(command, args, { cwd, env, shell = false, stdoutFilter, stderrFilte
 			stdio: ["inherit", stdoutFilter ? "pipe" : "inherit", stderrFilter ? "pipe" : "inherit"],
 			env: { ...process.env, PATH: binPath(cwd), ...FRAMEWORK_ENV, ...env },
 		});
-		onChild?.(child);
 		for (const [stream, filter] of [
 			[child.stdout, stdoutFilter],
 			[child.stderr, stderrFilter],
@@ -239,9 +233,6 @@ async function eject(appRoot, flags) {
 	}
 	console.log(`  ${dim("·")} the runtime is now yours, vendored as source in ${bold("src/_runtime/")}`);
 	console.log(`  ${dim("·")} @waniwani/kit imports point at src/_runtime/ — drop the dependency`);
-	console.log(
-		`  ${dim("·")} docs/*.md are inlined into ${bold("src/docs.ts")} — regenerate by hand from here on`,
-	);
 	console.log(
 		`  ${dim("·")} widgets/<name>/ no longer becomes a view — add ${bold("src/views/<name>.tsx")} by hand`,
 	);
@@ -277,7 +268,7 @@ function watchApp(appRoot, template) {
 		}, 120);
 	};
 
-	for (const dir of ["tools", "widgets", "flows", "docs"]) {
+	for (const dir of ["tools", "widgets", "flows"]) {
 		const path = join(appRoot, dir);
 		if (existsSync(path)) {
 			watch(path, { recursive: true }, rebuild);
@@ -297,176 +288,23 @@ function watchApp(appRoot, template) {
  * the framework's auto-open of its own DevTools page in the browser; the URL is
  * printed instead.
  */
-function devServer(outDir, { env, onChild } = {}) {
+function devServer(outDir) {
 	return run("node", [frameworkBin(), "dev", "--plain"], {
 		cwd: outDir,
-		env,
 		stderrFilter: devFilter(),
-		onChild,
 	});
 }
 
-const HEARTBEAT_MS = 30_000;
-const SESSION_DELETE_TIMEOUT_MS = 2_000;
-const DEFAULT_DEV_PORT = 3000;
-
-function parsePort(raw) {
-	const port = typeof raw === "string" ? Number(raw) : Number.NaN;
-	if (!Number.isInteger(port) || port < 1 || port > 65535) {
-		throw new Error("--port wants an integer between 1 and 65535");
-	}
-	return port;
-}
-
-/**
- * The port the dev server takes, which is also the port the tunnel's ingress is
- * pointed at.
- *
- * An explicit `--port` is taken at its word and fails when it is busy, since the
- * caller asked for that one. Otherwise the first free port from the configured
- * default is used: the alternative is a dev server that quietly moves to 3001
- * while the tunnel forwards to 3000.
- */
-async function resolveDevPort(flags, configured) {
-	// Presence, not truthiness: a bare `--port` with nothing after it parses as an
-	// undefined value, and picking a port anyway would ignore what was asked for.
-	if ("port" in flags) {
-		const port = parsePort(flags.port);
-		if (!(await isPortAvailable(port))) {
-			throw new Error(`port ${port} is in use: free it or pass a different --port`);
-		}
-		return port;
-	}
-	const start = configured ?? DEFAULT_DEV_PORT;
-	const port = await findAvailablePort(start);
-	if (port !== start) {
-		console.log(dim(`[waniwani] port ${start} is in use, using ${port}`));
-	}
-	return port;
-}
-
-/** `--open`. A dev loop prints its URLs and leaves the browser to the developer. */
-function openBrowser(url) {
-	const [command, args] =
-		process.platform === "darwin"
-			? ["open", [url]]
-			: process.platform === "win32"
-				? ["cmd", ["/c", "start", "", url]]
-				: ["xdg-open", [url]];
-	spawn(command, args, { stdio: "ignore", detached: true }).unref();
-}
+/** Flags that take a value; everything else is a boolean switch. */
+const VALUE_FLAGS = new Set(["out", "template", "name"]);
 
 /**
- * The dev loop, reachable from the internet and wired to the agent's playground.
- *
- * Everything `dev` does happens here too, on a port this command picks. What it
- * adds is the round trip to app.waniwani.ai: a connector token for the agent's
- * `<slug>.waniwani.dev` hostname, cloudflared running against it, and a dev
- * session held open by a heartbeat. The session is what points the playground at
- * this machine while the command runs, and at the deployed agent once it stops.
+ * `--out dir` / `--template=github:o/r#ref` alongside a positional app directory.
  *
- * Which account and which agent come from the two files `@waniwani/cli` and the
- * SDK already share (see ./account.mjs), and a missing one sends the developer
- * through that CLI's login or connect flow on the way in.
+ * `--no-install` sets `install` to false, so a switch that is on by default is
+ * read as one flag with two states instead of two flags a caller can set to
+ * contradict each other.
  */
-async function tunnel(appRoot, flags) {
-	const account = await connectAccount(appRoot);
-	const prepared = await prepare(appRoot, flags);
-	if (!prepared) return 1;
-
-	const port = await resolveDevPort(flags, account.devPort);
-	const client = createClient(account.apiUrl);
-	const sessions = `/api/mcp/projects/${account.projectId}/dev-session`;
-
-	let child = null;
-	let session = null;
-	let open = null;
-	let heartbeat = null;
-	let closing = false;
-
-	/**
-	 * Take down the session, the tunnel and the dev server, in that order.
-	 *
-	 * The session goes first and on a timeout: one left behind keeps the
-	 * playground calling a hostname that has stopped answering until the
-	 * heartbeat ages out server-side, and a slow API call is not a reason to
-	 * hold the terminal.
-	 */
-	const shutdown = async (code) => {
-		if (closing) return code;
-		closing = true;
-		clearInterval(heartbeat);
-		if (session) {
-			await Promise.race([
-				client.delete(`${sessions}/${session}`).catch(() => {}),
-				new Promise((resolveTimeout) => setTimeout(resolveTimeout, SESSION_DELETE_TIMEOUT_MS)),
-			]);
-		}
-		open?.stop();
-		if (child?.exitCode === null) child.kill("SIGTERM");
-		return code;
-	};
-
-	for (const signal of ["SIGINT", "SIGTERM"]) {
-		process.once(signal, () => {
-			void shutdown(0).then((code) => process.exit(code));
-		});
-	}
-
-	watchApp(appRoot, prepared.template);
-	const devLoop = devServer(prepared.outDir, {
-		env: { PORT: String(port) },
-		onChild: (spawned) => {
-			child = spawned;
-		},
-	});
-
-	// A dev server that dies on startup, from a port taken in the meantime or a
-	// broken vite config, would otherwise sit out the readiness timeout.
-	const earlyExit = devLoop.then((code) =>
-		Promise.reject(new Error(`the dev server exited with code ${code} before it was ready`)),
-	);
-
-	try {
-		console.log(dim(`[waniwani] waiting for the dev server on port ${port}…`));
-		try {
-			await Promise.race([waitForLocalServer(`http://localhost:${port}/`), earlyExit]);
-		} finally {
-			// The race is settled either way, so the loser's rejection needs an owner.
-			earlyExit.catch(() => {});
-		}
-
-		console.log(dim("[waniwani] opening the tunnel…"));
-		open = await startNamedTunnel(await client.post(`/api/mcp/projects/${account.projectId}/tunnel`, { port }));
-
-		// Creating the session takes no payload: the hostname the playground
-		// routes to is the tunnel's, and the API already holds it.
-		session = (await client.post(sessions, {})).id;
-		heartbeat = setInterval(() => {
-			// Silent on failure. A beat that does not land costs the session, and
-			// the playground falls back to the deployed agent.
-			void client.patch(`${sessions}/${session}`).catch(() => {});
-		}, HEARTBEAT_MS);
-
-		console.log("");
-		console.log(endpoint("public", `${open.publicUrl}/mcp`));
-		console.log(endpoint("try", account.playgroundUrl));
-		console.log("");
-		if (flags.open) {
-			openBrowser(account.playgroundUrl);
-		}
-
-		return await shutdown(await devLoop);
-	} catch (error) {
-		await shutdown(1);
-		throw error;
-	}
-}
-
-/** Flags that take a value; everything else is a boolean switch. */
-const VALUE_FLAGS = new Set(["out", "template", "port"]);
-
-/** `--out dir` / `--template=github:o/r#ref` alongside a positional app directory. */
 function parseArgs(argv) {
 	const flags = {};
 	const positional = [];
@@ -477,6 +315,10 @@ function parseArgs(argv) {
 			continue;
 		}
 		const [name, inline] = arg.slice(2).split("=");
+		if (name.startsWith("no-")) {
+			flags[name.slice(3)] = false;
+			continue;
+		}
 		flags[name] = VALUE_FLAGS.has(name) ? (inline ?? argv[++i]) : true;
 	}
 	return { flags, positional };
@@ -491,6 +333,12 @@ async function main() {
 		banner(PACKAGE_VERSION);
 	}
 
+	if (command === "init") {
+		// Whether a directory was named matters only here: with none, the answer to
+		// the one question decides where the app goes.
+		process.exit(await init(appRoot, flags, { targeted: positional.length > 0 }));
+	}
+
 	if (command === "check") {
 		const app = scanApp(appRoot);
 		const report = await validateApp(app);
@@ -505,10 +353,6 @@ async function main() {
 		process.exit(await devServer(prepared.outDir));
 	}
 
-	if (command === "tunnel") {
-		process.exit(await tunnel(appRoot, flags));
-	}
-
 	if (command === "build") {
 		const prepared = await prepare(appRoot, flags);
 		if (!prepared) process.exit(1);
@@ -529,22 +373,12 @@ async function main() {
 		);
 	}
 
-	if (command === "deploy") {
-		const prepared = await prepare(appRoot, flags);
-		if (!prepared) process.exit(1);
-		console.log(dim("[waniwani] deploying the generated project to Vercel…"));
-		const code = await run("vercel", ["deploy", ...(flags.prod ? ["--prod"] : [])], {
-			cwd: prepared.outDir,
-		});
-		process.exit(code);
-	}
-
 	if (command === "eject") {
 		process.exit(await eject(appRoot, flags));
 	}
 
 	console.error(red(`unknown command: ${command}`));
-	console.error(dim("usage: waniwani <check|dev|tunnel|build|start|deploy|eject> [dir]"));
+	console.error(dim("usage: waniwani <init|check|dev|build|start|eject> [dir]"));
 	process.exit(1);
 }