@mediamonks/canopy-cli 0.0.1 → 0.2.0

package/dist/docs-C3aOAx_A.mjs

@@ -0,0 +1,179 @@
+import { t as readConfig } from "./config-C-z7st1X.mjs";
+import { n as reportErrors } from "./ui-C8VuPzGp.mjs";
+import { defineCommand } from "citty";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/docs.ts
+/**
+* canopy docs — user/agent-facing guides, served live by the platform
+* (GET /v1/docs) so they never go stale, with a local cache and a bundled
+* snapshot as offline fallbacks.
+*
+* The platform requires a login for docs (internal platform), so fetches carry
+* the CLI token when there is one; without it we simply fall back to the
+* bundled snapshot, so `canopy docs` still works before sign-in.
+*
+* Resolution order for content:
+*   1. platform (unless a fresh cache exists and --refresh wasn't passed)
+*   2. local cache (~/.canopy/docs-cache/)
+*   3. bundled snapshot shipped with the CLI (dist/docs, repo docs/guides in dev)
+*/
+const cacheDir = join(homedir(), ".canopy", "docs-cache");
+const indexPath = join(cacheDir, "index.json");
+const CACHE_TTL_MS = 3600 * 1e3;
+const FETCH_TIMEOUT_MS = 4e3;
+/** The bundled snapshot dir: dist/docs when published, repo docs/guides in dev. */
+function bundledDocsDir() {
+	const base = fileURLToPath(new URL(".", import.meta.url));
+	for (const candidate of [join(base, "docs"), join(base, "..", "..", "..", "docs", "guides")]) if (existsSync(candidate)) return candidate;
+}
+/** Parse `---\ntitle: …\nsummary: …\n---\n<body>` frontmatter. */
+function parseFrontmatter(raw) {
+	const match = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/.exec(raw);
+	if (!match?.[1] || match[2] === void 0) return { body: raw.trim() };
+	const meta = {};
+	for (const line of match[1].split("\n")) {
+		const kv = /^([a-zA-Z0-9_-]+):\s*(.*)$/.exec(line);
+		if (kv?.[1]) meta[kv[1]] = (kv[2] ?? "").trim();
+	}
+	return {
+		title: meta["title"],
+		summary: meta["summary"],
+		body: match[2].trim()
+	};
+}
+/** Bearer header from the deploy token (CI) or the CLI login, if either exists. */
+function authHeaders() {
+	const token = process.env["CANOPY_DEPLOY_TOKEN"] || readConfig().token;
+	return token ? { authorization: `Bearer ${token}` } : {};
+}
+async function fetchRes(url) {
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+		const res = await fetch(url, {
+			signal: controller.signal,
+			headers: {
+				accept: "*/*",
+				...authHeaders()
+			}
+		});
+		clearTimeout(timer);
+		return res;
+	} catch {
+		return;
+	}
+}
+async function fetchJson(url) {
+	const res = await fetchRes(url);
+	return res?.ok ? await res.json() : void 0;
+}
+async function fetchText(url) {
+	const res = await fetchRes(url);
+	return res?.ok ? await res.text() : void 0;
+}
+function cacheFresh() {
+	try {
+		const { fetchedAt } = JSON.parse(readFileSync(indexPath, "utf8"));
+		return fetchedAt !== void 0 && Date.now() - Date.parse(fetchedAt) < CACHE_TTL_MS;
+	} catch {
+		return false;
+	}
+}
+function writeCache(file, content) {
+	try {
+		mkdirSync(cacheDir, { recursive: true });
+		writeFileSync(join(cacheDir, file), content);
+	} catch {}
+}
+/** Topics from cache, else from the bundled snapshot's frontmatter. */
+function topicsFromFallback() {
+	try {
+		const cached = JSON.parse(readFileSync(indexPath, "utf8"));
+		if (cached.topics?.length) return cached.topics;
+	} catch {}
+	const dir = bundledDocsDir();
+	if (!dir) return [];
+	return readdirSync(dir).filter((f) => f.endsWith(".md")).map((f) => {
+		const slug = f.replace(/\.md$/, "");
+		const { title, summary } = parseFrontmatter(readFileSync(join(dir, f), "utf8"));
+		return {
+			slug,
+			title: title ?? slug,
+			summary: summary ?? ""
+		};
+	});
+}
+/** A single doc's body from cache, else from the bundled snapshot. */
+function bodyFromFallback(slug) {
+	const cached = join(cacheDir, `${slug}.md`);
+	if (existsSync(cached)) return readFileSync(cached, "utf8");
+	const dir = bundledDocsDir();
+	const file = dir && join(dir, `${slug}.md`);
+	if (file && existsSync(file)) return parseFrontmatter(readFileSync(file, "utf8")).body;
+}
+async function listTopics(refresh) {
+	const { apiUrl } = readConfig();
+	if (refresh || !cacheFresh()) {
+		const data = await fetchJson(`${apiUrl}/v1/docs`);
+		if (data?.topics) {
+			writeCache("index.json", JSON.stringify({
+				fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
+				...data
+			}));
+			return data.topics;
+		}
+	}
+	return topicsFromFallback();
+}
+async function readTopic(slug, refresh) {
+	const { apiUrl } = readConfig();
+	if (refresh || !existsSync(join(cacheDir, `${slug}.md`))) {
+		const body = await fetchText(`${apiUrl}/v1/docs/${encodeURIComponent(slug)}`);
+		if (body !== void 0) {
+			writeCache(`${slug}.md`, body);
+			return body;
+		}
+	}
+	return bodyFromFallback(slug);
+}
+const docsCommand = defineCommand({
+	meta: {
+		name: "docs",
+		description: "Read the Canopy guides (offline-capable)"
+	},
+	args: {
+		topic: {
+			type: "positional",
+			required: false,
+			description: "Topic to print (omit to list)"
+		},
+		refresh: {
+			type: "boolean",
+			default: false,
+			description: "Re-fetch from the platform"
+		}
+	},
+	run: reportErrors("docs", async ({ args }) => {
+		const refresh = args.refresh;
+		const topic = args.topic;
+		if (!topic) {
+			const topics = await listTopics(refresh);
+			if (topics.length === 0) throw new Error("No docs available — check your connection, or reinstall the CLI.");
+			const width = Math.max(...topics.map((t) => t.slug.length));
+			console.log("Canopy docs — run `canopy docs <topic>`:\n");
+			for (const t of topics) console.log(`  ${t.slug.padEnd(width)}  ${t.summary}`);
+			return;
+		}
+		const body = await readTopic(topic, refresh);
+		if (body === void 0) {
+			const known = (await listTopics(false)).map((t) => t.slug).join(", ");
+			throw new Error(`No doc "${topic}".${known ? ` Available: ${known}.` : ""}`);
+		}
+		console.log(body);
+	})
+});
+//#endregion
+export { docsCommand };

package/dist/index.mjs

@@ -1,8 +1,7 @@
 #!/usr/bin/env node
+import { t as version } from "./package-OcWG7JAW.mjs";
+import { i as runRefresh, r as notifyOfUpdate } from "./version-check-CoWgQs2h.mjs";
 import { defineCommand, runMain } from "citty";
-//#region package.json
-var version = "0.0.1";
-//#endregion
 //#region src/index.ts
 /**
 * canopy — the Canopy CLI.
@@ -13,10 +12,15 @@ var version = "0.0.1";
 *   create                scaffold + register a project           [phase 1]
 *   dev [--local [--pull]] local dev: remote-first, or offline sandbox [phase 1/2]
 *   deploy                build & deploy assets (+ worker)        [phase 1/2]
+*   token create|list|revoke   deploy tokens for CI               [phase 2]
 *   db pull|snapshot|restore                                      [phase 2]
 *   logs                  tail the project's worker logs          [phase 2]
 *   open                  open the deployed project / dashboard   [phase 1]
 */
+if (process.env["CANOPY_UPDATE_REFRESH"] === "1") {
+	await runRefresh();
+	process.exit(0);
+}
 /** A roadmap command that has not landed yet (docs/04-roadmap.md). */
 function planned(name, description, phase) {
 	return defineCommand({
@@ -30,26 +34,32 @@ function planned(name, description, phase) {
 		}
 	});
 }
-await runMain(defineCommand({
+const main = defineCommand({
 	meta: {
 		name: "canopy",
 		version,
 		description: "canopy — create and deploy vibecoded projects"
 	},
 	subCommands: {
-		login: () => import("./login-DrXKOEmr.mjs").then((m) => m.loginCommand),
-		whoami: () => import("./login-DrXKOEmr.mjs").then((m) => m.whoamiCommand),
-		logout: () => import("./login-DrXKOEmr.mjs").then((m) => m.logoutCommand),
-		create: () => import("./projects-f_KocDae.mjs").then((m) => m.createCommand),
-		projects: () => import("./projects-f_KocDae.mjs").then((m) => m.projectsCommand),
-		delete: () => import("./projects-f_KocDae.mjs").then((m) => m.deleteCommand),
-		dev: () => import("./dev-Bvy21srH.mjs").then((m) => m.devCommand),
-		deploy: () => import("./deploy-BfhAlb91.mjs").then((m) => m.deployCommand),
-		rollback: () => import("./deploy-BfhAlb91.mjs").then((m) => m.rollbackCommand),
-		db: () => import("./db-BBcgT1md.mjs").then((m) => m.dbCommand),
-		open: () => import("./open-DFWvrLFc.mjs").then((m) => m.openCommand),
+		login: () => import("./login-Dif9Y32q.mjs").then((m) => m.loginCommand),
+		whoami: () => import("./login-Dif9Y32q.mjs").then((m) => m.whoamiCommand),
+		logout: () => import("./login-Dif9Y32q.mjs").then((m) => m.logoutCommand),
+		create: () => import("./projects-DJT_mJDR.mjs").then((m) => m.createCommand),
+		projects: () => import("./projects-DJT_mJDR.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-DJT_mJDR.mjs").then((m) => m.deleteCommand),
+		dev: () => import("./dev-D_GlUULk.mjs").then((m) => m.devCommand),
+		deploy: () => import("./deploy-N88l4Kt3.mjs").then((m) => m.deployCommand),
+		rollback: () => import("./deploy-N88l4Kt3.mjs").then((m) => m.rollbackCommand),
+		token: () => import("./token-rTD9jxPZ.mjs").then((m) => m.tokenCommand),
+		db: () => import("./db-CtUG4vfG.mjs").then((m) => m.dbCommand),
+		open: () => import("./open-xLiGUz_W.mjs").then((m) => m.openCommand),
+		docs: () => import("./docs-C3aOAx_A.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-jbmERP1X.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-Y8ejvoeg.mjs").then((m) => m.upgradeCommand),
 		logs: planned("logs", "Tail worker logs", "2")
 	}
-}));
+});
+if (process.argv[2] !== "upgrade") notifyOfUpdate(version);
+await runMain(main);
 //#endregion
 export {};

package/dist/{local-DhufX0eJ.mjs → local-951zc9qJ.mjs}

@@ -1,5 +1,5 @@
-import { t as apiRequest } from "./api-BEY4O4ap.mjs";
-import { n as rewriteApiPath } from "./dev-BB7CwqoI.mjs";
+import { t as apiRequest } from "./api-CyJ-wBZh.mjs";
+import { n as rewriteApiPath } from "./dev-DTGW0lm0.mjs";
 import { createRequire } from "node:module";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";

package/dist/{login-DrXKOEmr.mjs → login-Dif9Y32q.mjs}

@@ -1,4 +1,5 @@
-import { a as readConfig, n as reportErrors, o as writeConfig, t as openBrowser } from "./ui-Cl5P_yQ6.mjs";
+import { n as writeConfig, t as readConfig } from "./config-C-z7st1X.mjs";
+import { n as reportErrors, t as openBrowser } from "./ui-C8VuPzGp.mjs";
 import { defineCommand } from "citty";
 import * as p from "@clack/prompts";
 import { createHash, randomBytes } from "node:crypto";
@@ -78,10 +79,26 @@ const loginCommand = defineCommand({
 		name: "login",
 		description: "Sign in to Canopy via OneLogin"
 	},
-	run: reportErrors("login", () => login())
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Emit machine-readable status to stdout (for agents/CI)"
+	} },
+	run: reportErrors("login", async ({ args }) => {
+		const json = args.json;
+		try {
+			await login(json);
+		} catch (err) {
+			if (json) console.log(JSON.stringify({
+				status: "error",
+				message: err instanceof Error ? err.message : String(err)
+			}));
+			throw err;
+		}
+	})
 });
-async function login() {
-	p.intro("canopy login");
+async function login(json) {
+	if (!json) p.intro("canopy login");
 	const config = readConfig();
 	const { issuer, cliClientId, apiUrl } = config;
 	if (cliClientId.includes("REPLACE")) throw new Error("The CLI's OneLogin app is not configured yet (set CANOPY_OIDC_CLIENT_ID or packages/cli/src/config.ts).");
@@ -101,18 +118,24 @@ async function login() {
 		code_challenge_method: "S256"
 	}).toString();
 	const authorizeHref = authorizeUrl.toString();
-	p.note(`If nothing opens, visit:\n${authorizeHref}`, "Opening OneLogin in your browser");
 	openBrowser(authorizeHref);
-	const spin = p.spinner();
-	spin.start("Waiting for you to sign in in the browser…");
+	const spin = json ? void 0 : p.spinner();
+	if (json) console.log(JSON.stringify({
+		status: "waiting",
+		url: authorizeHref
+	}));
+	else {
+		p.note(`If nothing opens, visit:\n${authorizeHref}`, "Opening OneLogin in your browser");
+		spin?.start("Waiting for you to sign in in the browser…");
+	}
 	let code;
 	try {
 		code = await waitForCallback(state);
 	} catch (err) {
-		spin.error("Sign-in failed.");
+		spin?.error("Sign-in failed.");
 		throw err;
 	}
-	spin.stop("Signed in with OneLogin.");
+	spin?.stop("Signed in with OneLogin.");
 	const tokenRes = await fetch(discovery.token_endpoint, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
@@ -140,7 +163,12 @@ async function login() {
 		tokenExpiresAt: expires_at,
 		email: user.email
 	});
-	p.outro(`Logged in as ${user.name} <${user.email}> (token expires ${expires_at}).`);
+	if (json) console.log(JSON.stringify({
+		status: "ok",
+		email: user.email,
+		expiresAt: expires_at
+	}));
+	else p.outro(`Logged in as ${user.name} <${user.email}> (token expires ${expires_at}).`);
 }
 //#endregion
 export { loginCommand, logoutCommand, whoamiCommand };

package/dist/{open-DFWvrLFc.mjs → open-xLiGUz_W.mjs}

@@ -1,5 +1,5 @@
-import { n as reportErrors, t as openBrowser } from "./ui-Cl5P_yQ6.mjs";
-import { i as resolveProject, r as projectUrl, t as projectDirArgs } from "./project-CrrpLEPs.mjs";
+import { i as resolveProject, r as projectUrl, t as projectDirArgs } from "./project-CpiPLNby.mjs";
+import { n as reportErrors, t as openBrowser } from "./ui-C8VuPzGp.mjs";
 import { defineCommand } from "citty";
 //#region src/open.ts
 /**

package/dist/package-OcWG7JAW.mjs

@@ -0,0 +1,4 @@
+//#region package.json
+var version = "0.2.0";
+//#endregion
+export { version as t };

package/dist/{project-CrrpLEPs.mjs → project-CpiPLNby.mjs}

@@ -1,4 +1,4 @@
-import { a as readConfig } from "./ui-Cl5P_yQ6.mjs";
+import { t as readConfig } from "./config-C-z7st1X.mjs";
 import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 //#region src/project.ts

package/dist/projects-DJT_mJDR.mjs

@@ -0,0 +1,228 @@
+import { t as apiRequest } from "./api-CyJ-wBZh.mjs";
+import { r as projectUrl } from "./project-CpiPLNby.mjs";
+import { i as unwrap, n as reportErrors, r as requireTty } from "./ui-C8VuPzGp.mjs";
+import { defineCommand } from "citty";
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join, relative, resolve, sep } from "node:path";
+import * as p from "@clack/prompts";
+import { fileURLToPath } from "node:url";
+//#region src/template.ts
+/**
+* Template registry + scaffolder for `canopy create`. Templates are real,
+* runnable project directories in packages/templates — linted and built like
+* any code — copied into the CLI's dist/templates at build time
+* (scripts/sync-templates.mjs) so the published tarball is self-contained.
+*
+* Scaffolding copies a template recursively, substitutes {{name}}/{{slug}},
+* and renames _gitignore → .gitignore (npm strips .gitignore files from
+* published tarballs, so templates can't ship one under its real name).
+*/
+const TEMPLATES = [
+	{
+		id: "static",
+		label: "Static site",
+		hint: "plain html/css/js, no build step (default)"
+	},
+	{
+		id: "spa",
+		label: "React SPA",
+		hint: "Vite + React + TypeScript, SDK from npm",
+		needsInstall: true
+	},
+	{
+		id: "worker",
+		label: "React SPA + backend Worker",
+		hint: "adds Hono handlers in worker/ — Phase 2 preview",
+		needsInstall: true,
+		hidden: true
+	}
+];
+function templatesRoot() {
+	const base = fileURLToPath(new URL(".", import.meta.url));
+	for (const candidate of [join(base, "templates"), join(base, "..", "..", "templates")]) if (existsSync(join(candidate, "static"))) return candidate;
+	throw new Error("Template files not found — the CLI build is incomplete (missing templates/).");
+}
+function scaffoldTemplate(templateId, targetDir, vars) {
+	const source = join(templatesRoot(), templateId);
+	mkdirSync(targetDir, { recursive: true });
+	for (const entry of readdirSync(source, {
+		recursive: true,
+		withFileTypes: true
+	})) {
+		const dest = join(targetDir, relative(source, join(entry.parentPath, entry.name)).split(sep).map((part) => part === "_gitignore" ? ".gitignore" : part).join(sep));
+		if (entry.isDirectory()) {
+			mkdirSync(dest, { recursive: true });
+			continue;
+		}
+		writeFileSync(dest, readFileSync(join(entry.parentPath, entry.name), "utf8").replaceAll("{{name}}", vars.name).replaceAll("{{slug}}", vars.slug));
+	}
+}
+//#endregion
+//#region src/projects.ts
+/**
+* canopy create | projects | delete — the project registry from the terminal
+* (docs/04-roadmap.md Phase 1 item 2). `create` registers the project, then
+* scaffolds ./<slug>/ from the starter template (--no-scaffold to skip, e.g.
+* for an existing directory).
+*/
+function slugify(input) {
+	return input.toLowerCase().replaceAll(/[^a-z0-9]+/g, "-").replaceAll(/(^-+|-+$)/g, "").slice(0, 40);
+}
+const createCommand = defineCommand({
+	meta: {
+		name: "create",
+		description: "Create a new Canopy project"
+	},
+	args: {
+		name: {
+			type: "positional",
+			description: "Project name (prompted for when omitted)",
+			required: false
+		},
+		slug: {
+			type: "string",
+			description: "URL slug (defaults to a slugified name)"
+		},
+		template: {
+			type: "string",
+			description: `Template to scaffold: ${TEMPLATES.map((t) => t.id).join(" | ")} (picker when omitted)`
+		},
+		scaffold: {
+			type: "boolean",
+			default: true,
+			description: "Scaffold ./<slug>/ from the starter template",
+			negativeDescription: "Only register — no files written"
+		}
+	},
+	run: reportErrors("create", async ({ args }) => {
+		let name = args._.join(" ").trim();
+		p.intro("canopy create");
+		if (!name) {
+			requireTty("pass the project name as an argument.");
+			name = unwrap(await p.text({
+				message: "Project name",
+				validate: (value) => value?.trim() ? void 0 : "A project name is required."
+			})).trim();
+		}
+		let slug = args.slug;
+		if (!slug && process.stdin.isTTY) slug = unwrap(await p.text({
+			message: "Slug",
+			defaultValue: slugify(name),
+			placeholder: slugify(name),
+			validate: (value) => !value || /^[a-z0-9][a-z0-9-]*$/.test(value) ? void 0 : "Lowercase letters, digits and dashes only."
+		})).trim();
+		slug ||= slugify(name);
+		let template = TEMPLATES.find((t) => t.id === (args.template ?? "static"));
+		if (!template) throw new Error(`Unknown template "${args.template}" — available: ${TEMPLATES.map((t) => t.id).join(", ")}.`);
+		if (args.scaffold && !args.template && process.stdin.isTTY) {
+			const id = unwrap(await p.select({
+				message: "Template",
+				options: TEMPLATES.filter((t) => !t.hidden).map((t) => ({
+					value: t.id,
+					label: t.label,
+					hint: t.hint
+				}))
+			}));
+			template = TEMPLATES.find((t) => t.id === id) ?? template;
+		}
+		if (template.hidden) p.log.warn("Per-project Workers are not deployable yet (Phase 2) — `canopy deploy` publishes the frontend only for now.");
+		const targetDir = resolve(slug);
+		if (args.scaffold && existsSync(targetDir)) throw new Error(`Directory ./${slug} already exists — remove it, or use --no-scaffold to only register.`);
+		const spin = p.spinner();
+		spin.start(`Registering ${slug}…`);
+		let project;
+		try {
+			({project} = await apiRequest("POST", "/projects", {
+				slug,
+				name
+			}));
+		} catch (err) {
+			spin.error("Create failed.");
+			throw err;
+		}
+		spin.stop(`Created ${project.name} — ${projectUrl(project.slug)}`);
+		if (args.scaffold) {
+			scaffoldTemplate(template.id, targetDir, {
+				name,
+				slug
+			});
+			const steps = [
+				`cd ${slug}`,
+				...template.needsInstall ? ["npm install"] : [],
+				"canopy dev   (or deploy right away: canopy deploy)"
+			];
+			p.note(steps.join("\n"), `Scaffolded ./${slug}/ (${template.id}) — next`);
+			p.outro(`Live URL (after first deploy): ${projectUrl(project.slug)}`);
+		} else p.outro("Registered without scaffolding — add a canopy.json to deploy an existing app.");
+	})
+});
+const projectsCommand = defineCommand({
+	meta: {
+		name: "projects",
+		description: "List your projects"
+	},
+	args: { all: {
+		type: "boolean",
+		default: false,
+		description: "Include projects you can't edit"
+	} },
+	run: reportErrors("projects", async ({ args }) => {
+		const { projects, is_admin: isAdmin } = await apiRequest("GET", "/projects");
+		const mine = args.all || isAdmin ? projects : projects.filter((project) => project.role);
+		if (mine.length === 0) {
+			console.log(projects.length === 0 ? "No projects yet — run `canopy create`." : `No projects of your own yet — run \`canopy create\`, or --all to list all ${projects.length}.`);
+			return;
+		}
+		const width = Math.max(...mine.map((project) => project.slug.length));
+		for (const project of mine) {
+			const role = project.role ?? (isAdmin ? "admin" : `owner: ${project.owner_email}`);
+			console.log(`${project.slug.padEnd(width)}  ${project.status.padEnd(7)}  ${role.padEnd(6)}  ${projectUrl(project.slug)}  ${project.name}`);
+		}
+	})
+});
+const deleteCommand = defineCommand({
+	meta: {
+		name: "delete",
+		description: "Delete a project (full teardown)"
+	},
+	args: {
+		slug: {
+			type: "positional",
+			description: "Project slug (picked from a list when omitted)",
+			required: false
+		},
+		yes: {
+			type: "boolean",
+			default: false,
+			description: "Skip the type-the-slug confirmation"
+		}
+	},
+	run: reportErrors("delete", async ({ args }) => {
+		let slug = args.slug;
+		if (!slug) {
+			requireTty("pass the project slug as an argument.");
+			const listing = await apiRequest("GET", "/projects");
+			const projects = listing.is_admin ? listing.projects : listing.projects.filter((project) => project.role === "owner");
+			if (projects.length === 0) throw new Error("No projects to delete.");
+			slug = unwrap(await p.select({
+				message: "Project to delete",
+				options: projects.map((project) => ({
+					value: project.slug,
+					label: project.slug,
+					hint: project.name
+				}))
+			}));
+		}
+		if (!args.yes) {
+			requireTty("pass --yes to delete without confirmation.");
+			if (unwrap(await p.text({ message: `Delete "${slug}" permanently? This tears down its database and files. Type the slug to confirm.` })).trim() !== slug) {
+				p.cancel("Aborted.");
+				return;
+			}
+		}
+		await apiRequest("DELETE", `/projects/${slug}`);
+		p.log.success(`Deleted ${slug}.`);
+	})
+});
+//#endregion
+export { createCommand, deleteCommand, projectsCommand };

package/dist/skill/canopy/SKILL.md

@@ -0,0 +1,80 @@
+---
+name: canopy
+description: >-
+  Build, run, and deploy projects on Canopy — Monks' managed platform for
+  vibecoded apps (hosting + database + blob storage + AI). Use this whenever the
+  user wants to create a Canopy project, run/deploy one, manage its data or
+  deploy tokens, or asks how to use the `canopy` CLI. All platform docs are
+  available offline via `canopy docs`.
+---
+
+# Canopy
+
+Canopy is Monks' managed platform for vibecoded projects. Everything is driven
+by one CLI: **`canopy`**. This skill tells you how to drive it; the CLI itself
+carries the full, always-current documentation.
+
+## First: is the CLI installed and signed in?
+
+Run these before anything else, in order:
+
+```bash
+canopy --version   # is the CLI installed?
+canopy whoami      # is there a valid login?
+```
+
+- **`canopy --version` fails / command not found** → install it:
+
+  ```bash
+  npm install -g @mediamonks/canopy-cli
+  ```
+
+  (Needs Node.js 20+. If `npm` is missing, tell the user to install Node first.)
+
+- **`canopy whoami` says not logged in / expired** → run:
+  ```bash
+  canopy login
+  ```
+  This opens the user's browser. **Then STOP and tell the user to complete the
+  sign-in in their browser.** The command waits for them and finishes on its own.
+  - Never ask for or type the user's password, OneLogin codes, or any
+    credentials yourself.
+  - Login only works on the user's own machine (it uses a `127.0.0.1` redirect).
+    If you're on a remote/headless box, tell the user — it can't complete there.
+  - `canopy login --json` gives machine-readable status if you need to parse it.
+
+Skip login if `canopy whoami` already shows a valid, unexpired token.
+
+## Then: read the docs for whatever you're doing
+
+The CLI ships the full documentation and keeps it fresh from the platform. List
+the topics and read the relevant one _before_ running unfamiliar commands:
+
+```bash
+canopy docs            # list all topics
+canopy docs deploy     # print one topic
+```
+
+Available topics include: `getting-started`, `cli` (full command reference),
+`deploy`, `dev`, `data`, `ci`, `troubleshooting`. Always prefer `canopy docs`
+and `canopy <command> --help` over guessing flags — they are the source of
+truth and never go stale.
+
+## Command map (quick orientation — see `canopy docs cli` for detail)
+
+- Create a project: `canopy create`
+- Run locally: `canopy dev` (live data) or `canopy dev --local` (offline sandbox)
+- Deploy: `canopy deploy` (add `--build` if the project has a build step)
+- Roll back: `canopy rollback`
+- Open the live site: `canopy open`
+- Manage data: `canopy db pull | snapshot | snapshots | restore`
+- CI credentials: `canopy token create | list | revoke`
+
+## Safety rules
+
+- **Destructive commands** — `canopy db restore` and `canopy delete` wipe data.
+  Confirm intent with the user first, and take a `canopy db snapshot` before
+  restores.
+- **Deploys are public.** `canopy deploy` makes a version live. Confirm before
+  deploying unless the user clearly asked you to.
+- Keep the CLI current: `canopy upgrade` (this also refreshes this skill).