@mediamonks/canopy-cli 0.0.1

package/dist/login-DrXKOEmr.mjs

@@ -0,0 +1,146 @@
+import { a as readConfig, n as reportErrors, o as writeConfig, t as openBrowser } from "./ui-Cl5P_yQ6.mjs";
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+import { createHash, randomBytes } from "node:crypto";
+import { createServer } from "node:http";
+//#region src/login.ts
+/**
+* canopy login | whoami | logout — browser PKCE flow against OneLogin (public
+* client), then trade the ID token for a platform CLI token via POST
+* /v1/auth/cli-token. See docs/03-architecture.md "CLI auth".
+*/
+const CALLBACK_PORT = 8976;
+const REDIRECT_URI = `http://127.0.0.1:${CALLBACK_PORT}/callback`;
+const LOGIN_TIMEOUT_MS = 300 * 1e3;
+const base64url = (buf) => buf.toString("base64url");
+const whoamiCommand = defineCommand({
+	meta: {
+		name: "whoami",
+		description: "Show the current Canopy login"
+	},
+	run: reportErrors("whoami", async () => {
+		const config = readConfig();
+		if (!config.token) throw new Error("Not logged in — run `canopy login`.");
+		console.log(`${config.email ?? "<unknown email>"} — ${config.apiUrl}`);
+		if (config.tokenExpiresAt !== void 0) {
+			const expired = Date.parse(config.tokenExpiresAt) < Date.now();
+			console.log(expired ? `Token EXPIRED ${config.tokenExpiresAt} — run \`canopy login\` again.` : `Token expires ${config.tokenExpiresAt}.`);
+		}
+	})
+});
+const logoutCommand = defineCommand({
+	meta: {
+		name: "logout",
+		description: "Sign out: forget the local CLI token"
+	},
+	run: reportErrors("logout", async () => {
+		const config = readConfig();
+		if (!config.token) {
+			console.log("Not logged in.");
+			return;
+		}
+		const next = { ...config };
+		delete next.token;
+		delete next.tokenExpiresAt;
+		delete next.email;
+		writeConfig(next);
+		console.log(`Logged out${config.email ? ` (${config.email})` : ""} — token removed from ~/.canopy/config.json.`);
+	})
+});
+/** Wait for OneLogin to redirect back to the local loopback server. */
+function waitForCallback(expectedState) {
+	return new Promise((resolve, reject) => {
+		const server = createServer((req, res) => {
+			const url = new URL(req.url ?? "/", REDIRECT_URI);
+			if (url.pathname !== "/callback") {
+				res.writeHead(404).end();
+				return;
+			}
+			const code = url.searchParams.get("code");
+			const state = url.searchParams.get("state");
+			const ok = Boolean(code) && state === expectedState;
+			res.writeHead(ok ? 200 : 400, { "content-type": "text/html" }).end(ok ? "<h1>Logged in</h1><p>You can close this tab and return to the terminal.</p>" : "<h1>Login failed</h1><p>Return to the terminal and try again.</p>");
+			server.close();
+			clearTimeout(timer);
+			if (ok) resolve(code);
+			else reject(new Error(url.searchParams.get("error_description") ?? "Login rejected"));
+		});
+		const timer = setTimeout(() => {
+			server.close();
+			reject(/* @__PURE__ */ new Error("Timed out waiting for the browser login (5 minutes)."));
+		}, LOGIN_TIMEOUT_MS);
+		server.on("error", (err) => reject(err.message.includes("EADDRINUSE") ? /* @__PURE__ */ new Error(`Port ${CALLBACK_PORT} is in use — close the other process and retry.`) : err));
+		server.listen(CALLBACK_PORT, "127.0.0.1");
+	});
+}
+const loginCommand = defineCommand({
+	meta: {
+		name: "login",
+		description: "Sign in to Canopy via OneLogin"
+	},
+	run: reportErrors("login", () => login())
+});
+async function login() {
+	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).");
+	const discoveryRes = await fetch(`${issuer}/.well-known/openid-configuration`);
+	if (!discoveryRes.ok) throw new Error(`OIDC discovery failed: ${discoveryRes.status}`);
+	const discovery = await discoveryRes.json();
+	const state = base64url(randomBytes(32));
+	const codeVerifier = base64url(randomBytes(32));
+	const authorizeUrl = new URL(discovery.authorization_endpoint);
+	authorizeUrl.search = new URLSearchParams({
+		response_type: "code",
+		client_id: cliClientId,
+		redirect_uri: REDIRECT_URI,
+		scope: "openid profile email",
+		state,
+		code_challenge: base64url(createHash("sha256").update(codeVerifier).digest()),
+		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…");
+	let code;
+	try {
+		code = await waitForCallback(state);
+	} catch (err) {
+		spin.error("Sign-in failed.");
+		throw err;
+	}
+	spin.stop("Signed in with OneLogin.");
+	const tokenRes = await fetch(discovery.token_endpoint, {
+		method: "POST",
+		headers: { "content-type": "application/x-www-form-urlencoded" },
+		body: new URLSearchParams({
+			grant_type: "authorization_code",
+			client_id: cliClientId,
+			code,
+			redirect_uri: REDIRECT_URI,
+			code_verifier: codeVerifier
+		})
+	});
+	if (!tokenRes.ok) throw new Error(`Token exchange failed: ${tokenRes.status} ${await tokenRes.text()}`);
+	const { id_token: idToken } = await tokenRes.json();
+	if (!idToken) throw new Error("OneLogin returned no id_token.");
+	const cliTokenRes = await fetch(`${apiUrl}/v1/auth/cli-token`, {
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: JSON.stringify({ id_token: idToken })
+	});
+	if (!cliTokenRes.ok) throw new Error(`Canopy rejected the login: ${cliTokenRes.status} ${await cliTokenRes.text()}`);
+	const { token, expires_at, user } = await cliTokenRes.json();
+	writeConfig({
+		...config,
+		token,
+		tokenExpiresAt: expires_at,
+		email: user.email
+	});
+	p.outro(`Logged in as ${user.name} <${user.email}> (token expires ${expires_at}).`);
+}
+//#endregion
+export { loginCommand, logoutCommand, whoamiCommand };

package/dist/open-DFWvrLFc.mjs

@@ -0,0 +1,23 @@
+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 { defineCommand } from "citty";
+//#region src/open.ts
+/**
+* canopy open — open the deployed project in the browser
+* (docs/04-roadmap.md Phase 1).
+*/
+const openCommand = defineCommand({
+	meta: {
+		name: "open",
+		description: "Open the deployed project in your browser"
+	},
+	args: projectDirArgs,
+	run: reportErrors("open", async ({ args }) => {
+		const { slug } = resolveProject(args);
+		const url = projectUrl(slug);
+		console.log(`Opening ${url}`);
+		openBrowser(url);
+	})
+});
+//#endregion
+export { openCommand };

package/dist/project-CrrpLEPs.mjs

@@ -0,0 +1,54 @@
+import { a as readConfig } from "./ui-Cl5P_yQ6.mjs";
+import { readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+//#region src/project.ts
+/**
+* Which project is a command about? Every project-scoped command resolves it
+* the same way: `--project <slug>` wins, otherwise canopy.json in the target
+* directory (the optional [dir] positional, defaulting to the cwd).
+*/
+/** The wildcard apex projects are served under, derived from the API origin's registrable domain. */
+function projectUrl(slug) {
+	const apiHost = new URL(readConfig().apiUrl).hostname;
+	return `https://${slug}.${apiHost.endsWith("workers.dev") ? "thanarie.dev" : apiHost.split(".").slice(-2).join(".")}`;
+}
+/** canopy.json parsed if present; undefined when the file is missing. */
+function tryReadCanopyJson(dir) {
+	let raw;
+	try {
+		raw = readFileSync(join(dir, "canopy.json"), "utf8");
+	} catch {
+		return;
+	}
+	return JSON.parse(raw);
+}
+function readCanopyJson(dir) {
+	const config = tryReadCanopyJson(dir);
+	if (config === void 0) throw new Error(`No canopy.json in ${dir} — run from a project created by \`canopy create\`, add one ({"slug": "<slug>", "dist": "dist"}), or pass --project <slug>.`);
+	if (!config.slug) throw new Error("canopy.json is missing \"slug\".");
+	return config;
+}
+/** For commands scoped to a project but not to a directory (db, rollback). */
+const projectFlagArgs = { project: {
+	type: "string",
+	description: "Project slug (overrides canopy.json in the target directory)"
+} };
+/** For commands that operate on a project directory (dev, deploy, open). */
+const projectDirArgs = {
+	dir: {
+		type: "positional",
+		description: "Project directory (defaults to the current directory)",
+		required: false
+	},
+	...projectFlagArgs
+};
+/** Resolve the target directory and project slug from the shared args. */
+function resolveProject(args) {
+	const dir = resolve(args.dir ?? ".");
+	return {
+		dir,
+		slug: args.project ?? readCanopyJson(dir).slug
+	};
+}
+//#endregion
+export { tryReadCanopyJson as a, resolveProject as i, projectFlagArgs as n, projectUrl as r, projectDirArgs as t };

package/dist/projects-f_KocDae.mjs

@@ -0,0 +1,295 @@
+import { i as unwrap, n as reportErrors, r as requireTty } from "./ui-Cl5P_yQ6.mjs";
+import { t as apiRequest } from "./api-BEY4O4ap.mjs";
+import { r as projectUrl } from "./project-CrrpLEPs.mjs";
+import { defineCommand } from "citty";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import * as p from "@clack/prompts";
+import { join, resolve } from "node:path";
+//#region src/template.ts
+function templateFiles({ name, slug }) {
+	return {
+		"canopy.json": `${JSON.stringify({
+			slug,
+			dist: "."
+		}, null, 2)}\n`,
+		".gitignore": `.canopy/
+.DS_Store
+`,
+		"index.html": `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${name}</title>
+    <link rel="stylesheet" href="./style.css" />
+  </head>
+  <body>
+    <main>
+      <h1>${name}</h1>
+      <p class="status" id="status">connecting to Canopy…</p>
+      <section id="app">
+        <p class="placeholder">Start building — edit <code>main.js</code>, then run <code>canopy deploy</code>.</p>
+      </section>
+    </main>
+    <script type="module" src="./main.js"><\/script>
+  </body>
+</html>
+`,
+		"main.js": `// The Canopy SDK is served by the platform itself — nothing to install.
+// Auth (auth), data (db), files (blob) and AI (ai) are all live — see
+// CLAUDE.md for the full surface.
+import { createCanopy } from "/_api/v1/sdk.js";
+
+const canopy = createCanopy();
+
+const user = await canopy.auth.user();
+document.getElementById("status").textContent = \`signed in as \${user.email}\`;
+`,
+		"style.css": `:root {
+  font-family: system-ui, sans-serif;
+  color-scheme: light dark;
+}
+
+body {
+  margin: 0;
+  display: grid;
+  place-items: center;
+  min-height: 100vh;
+}
+
+main {
+  max-width: 40rem;
+  padding: 2rem;
+  text-align: center;
+}
+
+.status {
+  font-size: 0.9rem;
+  opacity: 0.7;
+}
+
+.placeholder {
+  border: 1px dashed color-mix(in srgb, currentColor 30%, transparent);
+  border-radius: 8px;
+  padding: 1.5rem;
+  opacity: 0.6;
+}
+`,
+		"CLAUDE.md": `# ${name} — a Canopy project
+
+This is a static web app on Canopy, the managed platform for internal Monks
+projects. Everything is served behind company login; there is no
+infrastructure to manage and none should be added.
+
+## The paved road
+
+- Frontend only: html/css/js in this directory (add a bundler if you must,
+  set \`build\` and \`dist\` in canopy.json accordingly).
+- All backend needs go through the Canopy SDK — never call external APIs with
+  secrets from the browser, never add your own server:
+  \`\`\`js
+  import { createCanopy } from "/_api/v1/sdk.js";
+  const canopy = createCanopy();
+  const user = await canopy.auth.user();          // { id, email, name, kind }
+
+  // Data — document collections on the project's own database (no tables, no migrations):
+  const todos = canopy.db.collection("todos");
+  const doc = await todos.insert({ title: "hi", done: false });   // -> data + { _id, _createdAt, _updatedAt }
+  await todos.find({ where: { done: false }, orderBy: "_createdAt", order: "desc", limit: 20 });
+  await todos.get(doc._id);                       // Doc | null
+  await todos.update(doc._id, { done: true });    // merge-patch; null removes a key
+  await todos.delete(doc._id);
+  await todos.search("groceries");                // full-text search over the collection
+  await canopy.db.sql("SELECT ... WHERE x = ?", [param]);         // raw SQL escape hatch, same database — always parameterize with ?
+
+  // Files — private storage on the project's own prefix (never public):
+  await canopy.blob.put("notes.txt", "hello", { contentType: "text/plain" });
+  const blob = await canopy.blob.get("notes.txt");                // Blob | null — .text(), .arrayBuffer(), URL.createObjectURL(...)
+  const { url } = await canopy.blob.getUrl("notes.txt");          // short-lived URL for <img src> / links
+  await canopy.blob.list("some/prefix/");         // [{ key, size, contentType, uploadedAt }]
+  await canopy.blob.delete("notes.txt");
+
+  // AI — LLM calls through the project's metered, budget-capped gateway:
+  const { message } = await canopy.ai.chat({ messages: [{ role: "user", content: "hi" }] });
+  // Streaming variant: canopy.ai.chatStream(sameOptions) -> SSE ReadableStream.
+  const { baseUrl, models } = await canopy.ai.endpoint();         // OpenAI-compatible base URL for ecosystem clients (same budget)
+  \`\`\`
+- AI spend is hard-capped per project; over budget, calls fail with
+  \`ai_budget_exceeded\` (429) — handle it, don't retry in a loop.
+- Develop with \`canopy dev\` — a local server on this directory whose
+  \`/_api\` proxies to the real platform. That is LIVE project data, the same
+  the deployed app uses: read freely, but take a \`canopy db snapshot\` before
+  risky data changes.
+- Prefer \`canopy dev --local\` for risky or destructive experiments — a
+  local-data sandbox (db/blob in \`.canopy/local/\`, writes never reach the
+  platform). Add \`--pull\` to hydrate it from a fresh copy of the live
+  database (pull-only; blobs stay empty). \`canopy.ai\` still works there —
+  it proxies to the platform and is metered as usual.
+- Deploy with \`canopy deploy\` — the live URL is
+  https://${slug}.thanarie.dev (company login required).
+
+## Boundaries
+
+- Do not add auth — the platform handles it before any request reaches this app.
+- Do not store secrets anywhere in this project.
+- Keep it a static site: no SSR, no custom servers, no databases outside canopy.db.
+`,
+		"README.md": `# ${name}
+
+A [Canopy](https://dashboard.thanarie.dev) project. Live (behind company
+login) at https://${slug}.thanarie.dev after the first \`canopy deploy\`.
+
+- \`canopy dev\` — develop locally against the live platform (real data!)
+- \`canopy dev --local [--pull]\` — offline sandbox with local data instead
+- \`canopy deploy\` — publish the current directory
+- \`CLAUDE.md\` — guardrails and SDK guide for coding agents
+`
+	};
+}
+//#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)"
+		},
+		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);
+		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) {
+			mkdirSync(targetDir, { recursive: true });
+			for (const [path, content] of Object.entries(templateFiles({
+				name,
+				slug
+			}))) writeFileSync(join(targetDir, path), content);
+			p.note(`cd ${slug}\ncanopy dev   (or deploy right away: canopy deploy)`, `Scaffolded ./${slug}/ — 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/ui-Cl5P_yQ6.mjs

@@ -0,0 +1,72 @@
+import { chmodSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { cancel, isCancel } from "@clack/prompts";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/config.ts
+/**
+* CLI config at ~/.canopy/config.json — platform endpoints and the current
+* CLI token. Env overrides: CANOPY_API_URL, CANOPY_OIDC_ISSUER,
+* CANOPY_OIDC_CLIENT_ID.
+*/
+const DEFAULT_API_URL = "https://canopy-api.arjan-van-wijk.workers.dev";
+const DEFAULT_ISSUER = "https://s4capital.onelogin.com/oidc/2";
+const DEFAULT_CLI_CLIENT_ID = "b69755d0-6678-013f-b5ce-09fe44a57aa0180501";
+const configDir = join(homedir(), ".canopy");
+const configPath = join(configDir, "config.json");
+function readConfig() {
+	let stored = {};
+	try {
+		stored = JSON.parse(readFileSync(configPath, "utf8"));
+	} catch {}
+	return {
+		...stored,
+		apiUrl: process.env["CANOPY_API_URL"] ?? stored.apiUrl ?? DEFAULT_API_URL,
+		issuer: process.env["CANOPY_OIDC_ISSUER"] ?? stored.issuer ?? DEFAULT_ISSUER,
+		cliClientId: process.env["CANOPY_OIDC_CLIENT_ID"] ?? stored.cliClientId ?? DEFAULT_CLI_CLIENT_ID
+	};
+}
+function writeConfig(config) {
+	mkdirSync(configDir, { recursive: true });
+	writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+	chmodSync(configPath, 384);
+}
+//#endregion
+//#region src/ui.ts
+/**
+* Shared terminal UX plumbing: clack prompt unwrapping and uniform
+* command error reporting.
+*/
+/** Unwrap a clack prompt result, exiting cleanly when the user cancels (ctrl-c). */
+function unwrap(result) {
+	if (isCancel(result)) {
+		cancel("Aborted.");
+		process.exit(130);
+	}
+	return result;
+}
+/** Wrap a command action so failures print as `canopy <name>: <message>` and exit 1. */
+function reportErrors(name, action) {
+	return async (...args) => {
+		try {
+			await action(...args);
+		} catch (err) {
+			console.error(`canopy ${name}: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+	};
+}
+/** Guard interactive prompts: bail with a actionable message on non-TTY runs. */
+function requireTty(hint) {
+	if (!process.stdin.isTTY) throw new Error(`This needs an interactive terminal — ${hint}`);
+}
+/** Open a URL in the default browser, fire-and-forget. */
+function openBrowser(url) {
+	spawn(process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open", [url], {
+		stdio: "ignore",
+		detached: true,
+		shell: process.platform === "win32"
+	}).on("error", () => {}).unref();
+}
+//#endregion
+export { readConfig as a, unwrap as i, reportErrors as n, writeConfig as o, requireTty as r, openBrowser as t };

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@mediamonks/canopy-cli",
+  "version": "0.0.1",
+  "description": "Canopy CLI — create, develop and deploy Canopy projects.",
+  "bin": {
+    "canopy": "./dist/index.mjs"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs",
+    "./package.json": "./package.json"
+  },
+  "dependencies": {
+    "@clack/prompts": "^1.7.0",
+    "citty": "^0.2.2",
+    "hono": "^4.8.0",
+    "miniflare": "^4.20260714.0",
+    "vite": "npm:@voidzero-dev/vite-plus-core@0.2.5",
+    "@mediamonks/canopy-data-plane": "0.0.1",
+    "@mediamonks/canopy": "0.0.1"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "typescript": "^7.0.2",
+    "vite-plus": "0.2.5"
+  },
+  "scripts": {
+    "build": "vp pack",
+    "dev": "vp pack --watch",
+    "test": "vp test",
+    "check": "vp check"
+  }
+}