@mediamonks/canopy-cli 0.0.1

package/dist/api-BEY4O4ap.mjs

@@ -0,0 +1,36 @@
+import { a as readConfig } from "./ui-Cl5P_yQ6.mjs";
+//#region src/api.ts
+/**
+* Authenticated requests to the Canopy control plane, using the CLI token
+* from `canopy login` (~/.canopy/config.json).
+*/
+var ApiError = class extends Error {
+	status;
+	code;
+	constructor(status, code, detail) {
+		super(detail ? `${code}: ${detail}` : code);
+		this.status = status;
+		this.code = code;
+	}
+};
+async function apiRequest(method, path, body, rawContentType) {
+	const config = readConfig();
+	if (!config.token) throw new Error("Not logged in — run `canopy login` first.");
+	const isForm = body instanceof FormData;
+	const response = await fetch(`${config.apiUrl}/v1${path}`, {
+		method,
+		headers: {
+			authorization: `Bearer ${config.token}`,
+			...body === void 0 || isForm ? {} : { "content-type": rawContentType ?? "application/json" }
+		},
+		body: body === void 0 ? void 0 : isForm ? body : rawContentType !== void 0 ? body : JSON.stringify(body)
+	});
+	if (!response.ok) {
+		const payload = await response.json().catch(() => ({}));
+		if (response.status === 401) throw new Error("Session expired — run `canopy login` again.");
+		throw new ApiError(response.status, payload.error ?? `http_${response.status}`, payload.detail);
+	}
+	return await response.json();
+}
+//#endregion
+export { apiRequest as t };

package/dist/db-BBcgT1md.mjs

@@ -0,0 +1,151 @@
+import { i as unwrap, n as reportErrors, r as requireTty } from "./ui-Cl5P_yQ6.mjs";
+import { t as apiRequest } from "./api-BEY4O4ap.mjs";
+import { i as resolveProject, n as projectFlagArgs } from "./project-CrrpLEPs.mjs";
+import { defineCommand } from "citty";
+import { readFileSync, writeFileSync } from "node:fs";
+import * as p from "@clack/prompts";
+//#region src/db.ts
+/**
+* canopy db pull | snapshot | snapshots | restore — data safety from the
+* terminal (docs/04-roadmap.md Phase 2 item 4, pulled forward).
+*
+* pull      download a fresh SQL dump of the project database
+* snapshot  store a dump server-side (restorable from CLI or dashboard)
+* snapshots list stored snapshots
+* restore   replace ALL project data from a snapshot or a local .sql file
+*
+* The project comes from canopy.json in the current directory, or
+* --project <slug>.
+*/
+const formatSize = (bytes) => bytes < 1024 * 1024 ? `${(bytes / 1024).toFixed(1)} kB` : `${(bytes / 1024 / 1024).toFixed(1)} MB`;
+const dbCommand = defineCommand({
+	meta: {
+		name: "db",
+		description: "Data tools: pull, snapshot, snapshots, restore"
+	},
+	subCommands: {
+		pull: defineCommand({
+			meta: {
+				name: "pull",
+				description: "Download a fresh SQL dump of the project database"
+			},
+			args: {
+				...projectFlagArgs,
+				out: {
+					type: "string",
+					description: "Output file (defaults to <slug>-<timestamp>.sql)"
+				}
+			},
+			run: reportErrors("db pull", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const out = args.out ?? `${slug}-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 19).replaceAll(/[:T]/g, "-")}.sql`;
+				const spin = p.spinner();
+				spin.start(`Exporting ${slug}…`);
+				try {
+					const { url } = await apiRequest("POST", `/projects/${slug}/export`);
+					const download = await fetch(url);
+					if (!download.ok) throw new Error(`Download failed (HTTP ${download.status}).`);
+					const sql = Buffer.from(await download.arrayBuffer());
+					writeFileSync(out, sql);
+					spin.stop(`Wrote ${out} (${formatSize(sql.byteLength)}).`);
+				} catch (err) {
+					spin.error("Export failed.");
+					throw err;
+				}
+			})
+		}),
+		snapshot: defineCommand({
+			meta: {
+				name: "snapshot",
+				description: "Store a dump server-side (restorable anytime)"
+			},
+			args: projectFlagArgs,
+			run: reportErrors("db snapshot", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const spin = p.spinner();
+				spin.start(`Snapshotting ${slug}…`);
+				let created;
+				try {
+					({snapshot: created} = await apiRequest("POST", `/projects/${slug}/snapshots`));
+				} catch (err) {
+					spin.error("Snapshot failed.");
+					throw err;
+				}
+				spin.stop(`Stored ${created.key} (${formatSize(created.size)}).`);
+				console.log(`Restore anytime with \`canopy db restore --snapshot ${created.key}\`.`);
+			})
+		}),
+		snapshots: defineCommand({
+			meta: {
+				name: "snapshots",
+				description: "List stored snapshots"
+			},
+			args: projectFlagArgs,
+			run: reportErrors("db snapshots", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const { snapshots } = await apiRequest("GET", `/projects/${slug}/snapshots`);
+				if (snapshots.length === 0) {
+					console.log(`No snapshots for ${slug} yet — run \`canopy db snapshot\`.`);
+					return;
+				}
+				for (const snapshot of snapshots) console.log(`${snapshot.key}  ${formatSize(snapshot.size).padStart(9)}  ${snapshot.createdAt}`);
+			})
+		}),
+		restore: defineCommand({
+			meta: {
+				name: "restore",
+				description: "Replace ALL project data from a snapshot or a local .sql file"
+			},
+			args: {
+				...projectFlagArgs,
+				file: {
+					type: "positional",
+					description: "Local .sql dump to restore from",
+					required: false
+				},
+				snapshot: {
+					type: "string",
+					description: "Server-side snapshot key to restore from"
+				},
+				yes: {
+					type: "boolean",
+					default: false,
+					description: "Skip the type-the-slug confirmation"
+				}
+			},
+			run: reportErrors("db restore", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const { file } = args;
+				let snapshotKey = args.snapshot;
+				if (!snapshotKey && !file) {
+					requireTty("pass a local .sql dump or --snapshot <key>.");
+					const { snapshots } = await apiRequest("GET", `/projects/${slug}/snapshots`);
+					if (snapshots.length === 0) throw new Error(`No snapshots for ${slug} — run \`canopy db snapshot\` first, or pass a local .sql dump.`);
+					snapshotKey = unwrap(await p.select({
+						message: `Snapshot to restore into ${slug}`,
+						options: snapshots.map((snapshot) => ({
+							value: snapshot.key,
+							label: snapshot.key,
+							hint: `${formatSize(snapshot.size)} · ${snapshot.createdAt}`
+						}))
+					}));
+				}
+				if (!args.yes) {
+					requireTty("pass --yes to restore without confirmation.");
+					if (unwrap(await p.text({ message: `Restore will REPLACE all current data in "${slug}" with ${snapshotKey ?? file}. Type the slug to confirm.` })).trim() !== slug) {
+						p.cancel("Aborted.");
+						return;
+					}
+				}
+				if (snapshotKey) await apiRequest("POST", `/projects/${slug}/restore`, { snapshot: snapshotKey });
+				else if (file) {
+					const sql = readFileSync(file, "utf8");
+					await apiRequest("POST", `/projects/${slug}/restore`, sql, "application/sql");
+				}
+				p.log.success(`Restored ${slug}.`);
+			})
+		})
+	}
+});
+//#endregion
+export { dbCommand };

package/dist/deploy-BfhAlb91.mjs

@@ -0,0 +1,152 @@
+import { i as unwrap, n as reportErrors } from "./ui-Cl5P_yQ6.mjs";
+import { t as apiRequest } from "./api-BEY4O4ap.mjs";
+import { a as tryReadCanopyJson, i as resolveProject, n as projectFlagArgs, r as projectUrl, t as projectDirArgs } from "./project-CrrpLEPs.mjs";
+import { defineCommand } from "citty";
+import { readFileSync, readdirSync, statSync } from "node:fs";
+import * as p from "@clack/prompts";
+import { join, relative, resolve } from "node:path";
+import { spawn } from "node:child_process";
+//#region src/deploy.ts
+/**
+* canopy deploy — build (optional), bundle the output directory as multipart
+* form-data and POST it to the control plane; the deploy is live immediately
+* (docs/04-roadmap.md Phase 1 item 3).
+*
+* Reads canopy.json in the project root:
+*   { "slug": "my-app", "dist": ".", "build": "npm run build" }
+*/
+const IGNORED = /* @__PURE__ */ new Set([
+	"canopy.json",
+	"CLAUDE.md",
+	"README.md",
+	".gitignore",
+	".DS_Store"
+]);
+const IGNORED_DIRS = /* @__PURE__ */ new Set([
+	".git",
+	"node_modules",
+	".claude"
+]);
+function runBuild(command, cwd) {
+	console.log(`Building: ${command}`);
+	return new Promise((resolvePromise, reject) => {
+		spawn(command, {
+			cwd,
+			shell: true,
+			stdio: "inherit"
+		}).on("close", (code) => {
+			if (code === 0) resolvePromise();
+			else reject(/* @__PURE__ */ new Error(`Build failed (exit ${code ?? "?"}).`));
+		});
+	});
+}
+function collectFiles(root, dir = root) {
+	const files = [];
+	for (const entry of readdirSync(dir, { withFileTypes: true })) {
+		const path = join(dir, entry.name);
+		if (entry.isDirectory()) {
+			if (!IGNORED_DIRS.has(entry.name) && !entry.name.startsWith(".")) files.push(...collectFiles(root, path));
+		} else if (!IGNORED.has(entry.name)) files.push(path);
+	}
+	return files;
+}
+const deployCommand = defineCommand({
+	meta: {
+		name: "deploy",
+		description: "Build and deploy the project"
+	},
+	args: {
+		...projectDirArgs,
+		build: {
+			type: "boolean",
+			default: true,
+			description: "Run the canopy.json build command first",
+			negativeDescription: "Skip the build, deploy the output directory as-is"
+		}
+	},
+	run: reportErrors("deploy", async ({ args }) => {
+		const { dir, slug } = resolveProject(args);
+		const config = tryReadCanopyJson(dir) ?? {};
+		if (config.build && args.build) await runBuild(config.build, dir);
+		const distDir = resolve(dir, config.dist ?? ".");
+		let paths;
+		try {
+			if (!statSync(distDir).isDirectory()) throw new Error("not a directory");
+			paths = collectFiles(distDir);
+		} catch {
+			throw new Error(`Output directory not found: ${distDir}`);
+		}
+		if (paths.length === 0) throw new Error(`Nothing to deploy in ${distDir}.`);
+		const form = new FormData();
+		let total = 0;
+		for (const path of paths) {
+			const data = readFileSync(path);
+			total += data.byteLength;
+			form.append(relative(distDir, path).replaceAll("\\", "/"), new Blob([data]));
+		}
+		const spin = p.spinner();
+		spin.start(`Deploying ${paths.length} files (${(total / 1024).toFixed(0)} kB) → ${slug}`);
+		let result;
+		try {
+			({deploy: result} = await apiRequest("POST", `/projects/${slug}/deploys`, form));
+		} catch (err) {
+			spin.error("Deploy failed.");
+			throw err;
+		}
+		spin.stop(`Live: ${projectUrl(slug)} (v${result.version})`);
+	})
+});
+/** Show the deploy history and ask which version to make live. */
+async function pickVersion(deploys, live) {
+	const fallback = live !== null && live > 1 ? live - 1 : void 0;
+	return unwrap(await p.select({
+		message: "Version to make live",
+		options: deploys.map((deploy) => ({
+			value: deploy.version,
+			label: `v${deploy.version}  ${deploy.created_at}  (${deploy.source})`,
+			hint: deploy.version === live ? "live" : void 0
+		})),
+		initialValue: fallback
+	}));
+}
+const rollbackCommand = defineCommand({
+	meta: {
+		name: "rollback",
+		description: "Make an earlier deploy live again (pick from history)"
+	},
+	args: {
+		version: {
+			type: "positional",
+			description: "Deploy version to make live, e.g. v3 (picked from a list when omitted)",
+			required: false
+		},
+		...projectFlagArgs,
+		dir: {
+			type: "string",
+			description: "Project directory (defaults to the current directory)"
+		}
+	},
+	run: reportErrors("rollback", async ({ args }) => {
+		const { slug } = resolveProject(args);
+		let target;
+		if (args.version !== void 0) {
+			if (!/^v?\d+$/.test(args.version)) throw new Error(`Invalid version "${args.version}" — expected a number like 3 or v3.`);
+			target = Number(args.version.replace(/^v/, ""));
+		} else {
+			const { deploys, live } = await apiRequest("GET", `/projects/${slug}/deploys`);
+			if (deploys.length < 2) throw new Error("Nothing to roll back to — this project has fewer than two deploys.");
+			if (process.stdin.isTTY) {
+				target = await pickVersion(deploys, live);
+				if (target === live) throw new Error(`v${target} is already live.`);
+			} else {
+				if (live === null || live < 2) throw new Error("Nothing to roll back to — no deploy exists before the live one.");
+				target = live - 1;
+			}
+		}
+		console.log(`Rolling back ${slug} to v${target}`);
+		const { live: result } = await apiRequest("POST", `/projects/${slug}/deploys/${target}/rollback`);
+		console.log(`Live: ${projectUrl(slug)} (v${result.version}, was v${result.previous ?? "?"})`);
+	})
+});
+//#endregion
+export { deployCommand, rollbackCommand };

package/dist/dev-BB7CwqoI.mjs

@@ -0,0 +1,170 @@
+import { a as readConfig, n as reportErrors } from "./ui-Cl5P_yQ6.mjs";
+import { t as apiRequest } from "./api-BEY4O4ap.mjs";
+import { i as resolveProject, t as projectDirArgs } from "./project-CrrpLEPs.mjs";
+import { defineCommand } from "citty";
+import { join } from "node:path";
+//#region src/dev.ts
+/**
+* Mirror the gateway's project-host rewrite (apps/gateway/src/index.ts):
+* strip /_api, then scope bare data-plane module paths onto this project.
+* Control-plane paths (and /v1/sdk.js) pass through untouched.
+*/
+function rewriteApiPath(path, slug) {
+	const queryStart = path.indexOf("?");
+	const query = queryStart === -1 ? "" : path.slice(queryStart);
+	let pathname = (queryStart === -1 ? path : path.slice(0, queryStart)).slice(5);
+	const dataPlane = /^\/v1\/(db|blob|ai|services)(\/.*)?$/.exec(pathname);
+	if (dataPlane) pathname = `/v1/projects/${slug}/${dataPlane[1]}${dataPlane[2] ?? ""}`;
+	return pathname + query;
+}
+async function startVite(flags, serverOverrides) {
+	const { createServer } = await import("vite");
+	const server = await createServer({
+		root: flags.dir,
+		plugins: [{
+			name: "canopy-platform-api-external",
+			resolveId: (id) => id.startsWith("/_api/") ? {
+				id,
+				external: true
+			} : void 0
+		}],
+		server: {
+			port: flags.port,
+			...serverOverrides
+		}
+	});
+	await server.listen();
+	return server;
+}
+async function devRemote(flags, slug) {
+	const { token, expires_at } = await apiRequest("POST", `/projects/${slug}/dev-token`);
+	const { apiUrl } = readConfig();
+	const server = await startVite(flags, { proxy: { "/_api": {
+		target: apiUrl,
+		changeOrigin: true,
+		headers: { authorization: `Bearer ${token}` },
+		rewrite: (path) => rewriteApiPath(path, slug)
+	} } });
+	console.log(`\n  ${slug} — remote-first dev against LIVE project data`);
+	console.log("  (worried about a risky change? `canopy db snapshot` first, or work");
+	console.log("   on a local copy instead: `canopy dev --local --pull`)\n");
+	server.printUrls();
+	console.log(`\n  Dev token expires ${expires_at} — restart canopy dev after that.`);
+}
+async function devLocal(flags, slug) {
+	let dump;
+	if (flags.pull) {
+		const { fetchProjectDump } = await import("./local-DhufX0eJ.mjs");
+		console.log(`Pulling a fresh export of ${slug}…`);
+		dump = await fetchProjectDump(slug);
+	}
+	let remote;
+	try {
+		const { token } = await apiRequest("POST", `/projects/${slug}/dev-token`);
+		remote = {
+			target: readConfig().apiUrl,
+			token
+		};
+	} catch (err) {
+		console.log(`Note: ai/services will be unavailable — could not reach the platform (${err instanceof Error ? err.message : String(err)}).`);
+	}
+	const { createSandbox } = await import("./local-DhufX0eJ.mjs");
+	const sandbox = await createSandbox({
+		slug,
+		persistDir: join(flags.dir, ".canopy", "local"),
+		email: readConfig().email
+	});
+	if (dump !== void 0) {
+		await sandbox.applyDump(dump);
+		console.log(`Hydrated the sandbox (${(dump.length / 1024).toFixed(1)} kB of SQL).`);
+	}
+	const handleApi = async (req, res) => {
+		const chunks = [];
+		for await (const chunk of req) chunks.push(chunk);
+		const body = Buffer.concat(chunks);
+		const headers = new Headers();
+		if (req.headers["content-type"]) headers.set("content-type", req.headers["content-type"]);
+		const response = await sandbox.handle(new Request(`http://canopy.local${req.url ?? ""}`, {
+			method: req.method,
+			headers,
+			body: body.length === 0 ? void 0 : new Uint8Array(body)
+		}));
+		res.writeHead(response.status, Object.fromEntries(response.headers));
+		res.end(Buffer.from(await response.arrayBuffer()));
+	};
+	const { createServer: createHttpServer } = await import("node:http");
+	const apiServer = createHttpServer((req, res) => {
+		handleApi(req, res).catch((err) => {
+			res.writeHead(500, { "content-type": "application/json" });
+			res.end(JSON.stringify({
+				error: "local_sandbox_error",
+				detail: String(err)
+			}));
+		});
+	});
+	await new Promise((done) => apiServer.listen(0, "127.0.0.1", done));
+	const apiAddress = apiServer.address();
+	if (apiAddress === null || typeof apiAddress === "string") throw new Error("Could not bind the local sandbox server.");
+	const remoteEntry = remote && {
+		target: remote.target,
+		changeOrigin: true,
+		headers: { authorization: `Bearer ${remote.token}` },
+		rewrite: (path) => rewriteApiPath(path, slug)
+	};
+	const server = await startVite(flags, { proxy: {
+		...remoteEntry && {
+			"/_api/v1/ai": remoteEntry,
+			"/_api/v1/services": remoteEntry
+		},
+		"/_api": { target: `http://127.0.0.1:${apiAddress.port}` }
+	} });
+	server.httpServer?.once("close", () => {
+		apiServer.close();
+		sandbox.dispose();
+	});
+	console.log(`\n  ${slug} — LOCAL sandbox (Miniflare D1/R2 in .canopy/local/)`);
+	console.log("  data is yours alone: db and blob writes never reach the platform");
+	if (dump === void 0) console.log("  (want prod data? restart with --pull to hydrate from a fresh export)");
+	console.log("  blobs are not pulled — the local blob store starts empty");
+	console.log(remote ? "  ai/services pass through to the platform (metered as usual)" : "  ai/services answer 501 until you log in and restart");
+	console.log("");
+	server.printUrls();
+}
+const devCommand = defineCommand({
+	meta: {
+		name: "dev",
+		description: "Run the project locally (remote-first; --local [--pull] for a sandbox)"
+	},
+	args: {
+		...projectDirArgs,
+		port: {
+			type: "string",
+			description: "Dev server port"
+		},
+		local: {
+			type: "boolean",
+			default: false,
+			description: "Local-data sandbox (Miniflare D1/R2 under .canopy/local/) instead of live data"
+		},
+		pull: {
+			type: "boolean",
+			default: false,
+			description: "Hydrate the sandbox from a fresh prod export first (requires --local)"
+		}
+	},
+	run: reportErrors("dev", async ({ args }) => {
+		const port = args.port === void 0 ? void 0 : Number(args.port);
+		if (port !== void 0 && !Number.isInteger(port)) throw new Error(`Invalid --port=${args.port}`);
+		if (args.pull && !args.local) throw new Error("--pull only makes sense with --local (remote dev already sees live data).");
+		const { dir, slug } = resolveProject(args);
+		const flags = {
+			dir,
+			port,
+			local: args.local,
+			pull: args.pull
+		};
+		await (flags.local ? devLocal(flags, slug) : devRemote(flags, slug));
+	})
+});
+//#endregion
+export { rewriteApiPath as n, devCommand as t };

package/dist/dev-Bvy21srH.mjs

@@ -0,0 +1,2 @@
+import { t as devCommand } from "./dev-BB7CwqoI.mjs";
+export { devCommand };

package/dist/index.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+import { defineCommand, runMain } from "citty";
+//#region package.json
+var version = "0.0.1";
+//#endregion
+//#region src/index.ts
+/**
+* canopy — the Canopy CLI.
+*
+* Commands are citty subcommands, lazily imported so startup stays snappy.
+* Planned commands (docs/04-roadmap.md):
+*   login                 OneLogin sign-in (browser, PKCE)        [phase 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]
+*   db pull|snapshot|restore                                      [phase 2]
+*   logs                  tail the project's worker logs          [phase 2]
+*   open                  open the deployed project / dashboard   [phase 1]
+*/
+/** A roadmap command that has not landed yet (docs/04-roadmap.md). */
+function planned(name, description, phase) {
+	return defineCommand({
+		meta: {
+			name,
+			description: `${description} (not implemented yet — Phase ${phase})`
+		},
+		run() {
+			console.error(`canopy ${name}: not implemented yet — lands in Phase ${phase} (docs/04-roadmap.md).`);
+			process.exit(1);
+		}
+	});
+}
+await runMain(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),
+		logs: planned("logs", "Tail worker logs", "2")
+	}
+}));
+//#endregion
+export {};