@mediamonks/canopy-cli 0.0.1 → 0.2.0

package/dist/templates/worker/src/style.css

@@ -0,0 +1,29 @@
+: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;
+}

package/dist/templates/worker/tsconfig.json

@@ -0,0 +1,16 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "lib": ["ES2022", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "jsx": "react-jsx",
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "noUncheckedIndexedAccess": true
+  },
+  "include": ["src", "worker", "vite.config.ts"]
+}

package/dist/templates/worker/vite.config.ts

@@ -0,0 +1,7 @@
+import react from "@vitejs/plugin-react";
+import { defineConfig } from "vite";
+
+// `canopy dev` picks this config up and adds its own /_api proxy on top.
+export default defineConfig({
+  plugins: [react()],
+});

package/dist/templates/worker/worker/index.ts

@@ -0,0 +1,29 @@
+/**
+ * The project's own backend Worker (Hono-style handlers). It runs behind the
+ * Canopy gateway — every request is already authenticated — and reaches the
+ * platform (db/blob/ai) through the CANOPY service binding, so budgets and
+ * data isolation still apply.
+ *
+ * NOTE: per-project Workers are a Canopy Phase 2 capability. `canopy deploy`
+ * does not upload this Worker yet — the frontend deploys like any SPA, and
+ * this directory is picked up automatically once the platform supports it.
+ */
+
+import { createCanopy } from "@mediamonks/canopy";
+import { Hono } from "hono";
+
+interface Env {
+  // Service binding to the platform API (canopy-api), scoped to this project.
+  CANOPY: { fetch: typeof fetch };
+}
+
+const app = new Hono<{ Bindings: Env }>();
+
+// Routes under /api/* reach this Worker; everything else serves the SPA.
+app.get("/api/hello", async (c) => {
+  const canopy = createCanopy({ fetch: c.env.CANOPY.fetch.bind(c.env.CANOPY) });
+  const user = await canopy.auth.user();
+  return c.json({ message: `Hello from the backend, ${user.name}!` });
+});
+
+export default app;

package/dist/token-rTD9jxPZ.mjs

@@ -0,0 +1,75 @@
+import { t as apiRequest } from "./api-CyJ-wBZh.mjs";
+import { i as resolveProject, n as projectFlagArgs, t as projectDirArgs } from "./project-CpiPLNby.mjs";
+import { n as reportErrors } from "./ui-C8VuPzGp.mjs";
+import { defineCommand } from "citty";
+const tokenCommand = defineCommand({
+	meta: {
+		name: "token",
+		description: "Manage deploy tokens for push-to-main deploys (CI)"
+	},
+	subCommands: {
+		create: defineCommand({
+			meta: {
+				name: "create",
+				description: "Create a deploy token for CI"
+			},
+			args: {
+				...projectDirArgs,
+				name: {
+					type: "string",
+					description: "Label shown in the dashboard, e.g. \"GitHub Actions\""
+				}
+			},
+			run: reportErrors("token create", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const { token } = await apiRequest("POST", `/projects/${slug}/deploy-tokens`, { name: args.name });
+				console.log(`Deploy token for ${slug} (shown once — store it now):\n`);
+				console.log(`  ${token}\n`);
+				console.log("Add it to the GitHub repo as secret CANOPY_DEPLOY_TOKEN");
+				console.log("(gh secret set CANOPY_DEPLOY_TOKEN, or repo Settings → Secrets).");
+				console.log("Pushes to main then deploy via .github/workflows/canopy-deploy.yml.");
+			})
+		}),
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List the project's deploy tokens"
+			},
+			args: { ...projectDirArgs },
+			run: reportErrors("token list", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const { tokens } = await apiRequest("GET", `/projects/${slug}/deploy-tokens`);
+				if (tokens.length === 0) {
+					console.log(`No deploy tokens for ${slug} — create one with \`canopy token create\`.`);
+					return;
+				}
+				for (const t of tokens) console.log(`${t.id}  ${t.name ?? "(unnamed)"}  created ${t.created_at} by ${t.created_by ?? "?"}`);
+			})
+		}),
+		revoke: defineCommand({
+			meta: {
+				name: "revoke",
+				description: "Revoke a deploy token (id from `canopy token list`)"
+			},
+			args: {
+				id: {
+					type: "positional",
+					description: "Token id to revoke",
+					required: true
+				},
+				...projectFlagArgs,
+				dir: {
+					type: "string",
+					description: "Project directory (defaults to the current directory)"
+				}
+			},
+			run: reportErrors("token revoke", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				await apiRequest("DELETE", `/projects/${slug}/deploy-tokens/${args.id}`);
+				console.log(`Revoked ${args.id} — deploys using it stop working immediately.`);
+			})
+		})
+	}
+});
+//#endregion
+export { tokenCommand };

package/dist/ui-C8VuPzGp.mjs

@@ -0,0 +1,40 @@
+import { spawn } from "node:child_process";
+import { cancel, isCancel } from "@clack/prompts";
+//#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 { unwrap as i, reportErrors as n, requireTty as r, openBrowser as t };

package/dist/upgrade-Y8ejvoeg.mjs

@@ -0,0 +1,99 @@
+import { t as PACKAGE_NAME } from "./version-check-CoWgQs2h.mjs";
+import { n as reportErrors } from "./ui-C8VuPzGp.mjs";
+import { defineCommand } from "citty";
+import { spawn } from "node:child_process";
+//#region src/upgrade.ts
+/**
+* canopy upgrade — install the latest published CLI globally.
+*
+* We shell out to whichever package manager we can detect (npm/pnpm/yarn/bun),
+* defaulting to npm, and let it do the actual install so global prefixes,
+* permissions and lockfiles stay the manager's concern. `--pm` overrides the
+* guess; `--version` pins a specific release.
+*/
+/** Best-effort guess of the package manager that installed this CLI. */
+function detectPackageManager() {
+	const ua = process.env["npm_config_user_agent"] ?? "";
+	if (ua.startsWith("pnpm")) return "pnpm";
+	if (ua.startsWith("yarn")) return "yarn";
+	if (ua.startsWith("bun")) return "bun";
+	const path = process.argv[1] ?? process.execPath;
+	if (/[\\/](?:pnpm|\.pnpm)[\\/]/.test(path)) return "pnpm";
+	if (/[\\/]\.bun[\\/]/.test(path)) return "bun";
+	if (/[\\/](?:Yarn|\.yarn)[\\/]/i.test(path)) return "yarn";
+	return "npm";
+}
+/** The global-install argv for `pm`, targeting `spec` (e.g. name@latest). */
+function installArgs(pm, spec) {
+	switch (pm) {
+		case "pnpm": return [
+			"add",
+			"-g",
+			spec
+		];
+		case "yarn": return [
+			"global",
+			"add",
+			spec
+		];
+		case "bun": return [
+			"add",
+			"-g",
+			spec
+		];
+		default: return [
+			"install",
+			"-g",
+			spec
+		];
+	}
+}
+function run(command, args) {
+	return new Promise((resolve, reject) => {
+		const child = spawn(command, args, {
+			stdio: "inherit",
+			shell: process.platform === "win32"
+		});
+		child.on("error", (err) => reject(err.code === "ENOENT" ? /* @__PURE__ */ new Error(`\`${command}\` was not found on your PATH.`) : err));
+		child.on("close", (code) => code === 0 ? resolve() : reject(/* @__PURE__ */ new Error(`${command} exited with code ${code ?? "unknown"}.`)));
+	});
+}
+const upgradeCommand = defineCommand({
+	meta: {
+		name: "upgrade",
+		description: "Update the Canopy CLI to the latest version"
+	},
+	args: {
+		version: {
+			type: "string",
+			description: "Install this exact version instead of the latest"
+		},
+		pm: {
+			type: "string",
+			description: "Package manager to use: npm, pnpm, yarn or bun (auto-detected by default)"
+		}
+	},
+	run: reportErrors("upgrade", async ({ args }) => {
+		const chosen = args.pm;
+		if (chosen && ![
+			"npm",
+			"pnpm",
+			"yarn",
+			"bun"
+		].includes(chosen)) throw new Error(`Unknown --pm "${chosen}" — use npm, pnpm, yarn or bun.`);
+		const pm = chosen ?? detectPackageManager();
+		const cmd = installArgs(pm, `${PACKAGE_NAME}@${args.version ?? "latest"}`);
+		console.log(`Upgrading via ${pm}: ${pm} ${cmd.join(" ")}`);
+		await run(pm, cmd);
+		console.log(`\nDone. Run \`canopy --version\` to confirm.`);
+		const { skillInstalled } = await import("./skill-jbmERP1X.mjs");
+		if (skillInstalled(process.cwd())) {
+			console.log("Refreshing the Canopy agent skill in this repo…");
+			await run("canopy", ["skill", "install"]).catch((err) => {
+				console.warn(`Could not auto-refresh the skill (${err instanceof Error ? err.message : String(err)}). Run \`canopy skill install\` yourself.`);
+			});
+		}
+	})
+});
+//#endregion
+export { upgradeCommand };

package/dist/version-check-CoWgQs2h.mjs

@@ -0,0 +1,128 @@
+import { spawn } from "node:child_process";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+//#region src/version-check.ts
+/**
+* Best-effort "you're behind" notice for the CLI.
+*
+* On startup we read a small cache at ~/.canopy/version-check.json and, if a
+* newer version is already known, print a one-line hint to stderr. Refreshing
+* that cache from the npm registry happens in a detached background process so
+* it never blocks (or delays) the command the user actually ran. The check is
+* silent on any failure and can be disabled with CANOPY_NO_UPDATE_CHECK.
+*/
+const PACKAGE_NAME = "@mediamonks/canopy-cli";
+const CACHE_PATH = join(homedir(), ".canopy", "version-check.json");
+const CHECK_INTERVAL_MS = 1440 * 60 * 1e3;
+const REFRESH_TIMEOUT_MS = 3e3;
+const REFRESH_ENV = "CANOPY_UPDATE_REFRESH";
+/** The npm registry to query, honouring an npm/pnpm registry override. */
+function registryUrl() {
+	return `${(process.env["npm_config_registry"] ?? "https://registry.npmjs.org").replace(/\/$/, "")}/${PACKAGE_NAME}/latest`;
+}
+/**
+* Compare two semver strings. Returns -1 if a < b, 1 if a > b, 0 if equal.
+* Handles `x.y.z` with an optional `-prerelease`; a prerelease sorts below its
+* release (1.2.0-rc.1 < 1.2.0). Good enough for a behind/ahead check.
+*/
+function compareSemver(a, b) {
+	const parse = (v) => {
+		const [core = "", pre = ""] = v.replace(/^v/, "").split("-", 2);
+		return {
+			nums: core.split(".").map((n) => Number.parseInt(n, 10) || 0),
+			pre: pre ? pre.split(".") : []
+		};
+	};
+	const pa = parse(a);
+	const pb = parse(b);
+	for (let i = 0; i < 3; i++) {
+		const diff = (pa.nums[i] ?? 0) - (pb.nums[i] ?? 0);
+		if (diff !== 0) return diff < 0 ? -1 : 1;
+	}
+	if (pa.pre.length === 0 && pb.pre.length === 0) return 0;
+	if (pa.pre.length === 0) return 1;
+	if (pb.pre.length === 0) return -1;
+	for (let i = 0; i < Math.max(pa.pre.length, pb.pre.length); i++) {
+		const x = pa.pre[i];
+		const y = pb.pre[i];
+		if (x === y) continue;
+		if (x === void 0) return -1;
+		if (y === void 0) return 1;
+		const nx = Number(x);
+		const ny = Number(y);
+		return (!Number.isNaN(nx) && !Number.isNaN(ny) ? nx - ny : x < y ? -1 : 1) < 0 ? -1 : 1;
+	}
+	return 0;
+}
+function readCache() {
+	try {
+		return JSON.parse(readFileSync(CACHE_PATH, "utf8"));
+	} catch {
+		return;
+	}
+}
+function writeCache(cache) {
+	try {
+		mkdirSync(join(homedir(), ".canopy"), { recursive: true });
+		writeFileSync(CACHE_PATH, `${JSON.stringify(cache, null, 2)}\n`);
+	} catch {}
+}
+/** Should we stay out of the way entirely (opt-out, CI, or piped output)? */
+function disabled() {
+	return process.env["CANOPY_NO_UPDATE_CHECK"] === "1" || process.env["CI"] !== void 0 || !process.stderr.isTTY;
+}
+/**
+* Print an update hint from cache (if we're behind), then kick off a detached
+* background refresh when the cache is stale. Never throws, never blocks.
+*/
+function notifyOfUpdate(currentVersion) {
+	if (disabled()) return;
+	const cache = readCache();
+	if (cache?.latest && compareSemver(currentVersion, cache.latest) < 0) process.stderr.write(`\nUpdate available: ${currentVersion} → ${cache.latest}. Run \`canopy upgrade\` to update.\n\n`);
+	if (!(cache && Date.now() - Date.parse(cache.lastCheck) < CHECK_INTERVAL_MS)) spawnBackgroundRefresh();
+}
+/** Spawn `canopy` again, flagged to only refresh the cache, fully detached. */
+function spawnBackgroundRefresh() {
+	try {
+		const entry = process.argv[1];
+		if (entry === void 0) return;
+		const child = spawn(process.execPath, [entry], {
+			detached: true,
+			stdio: "ignore",
+			env: {
+				...process.env,
+				[REFRESH_ENV]: "1"
+			}
+		});
+		child.on("error", () => {});
+		child.unref();
+	} catch {}
+}
+/**
+* The detached process's whole job: fetch the latest version and update the
+* cache. Always records lastCheck so a flaky registry doesn't cause a fetch on
+* every single invocation. Exits the process when done.
+*/
+async function runRefresh() {
+	const cache = {
+		lastCheck: (/* @__PURE__ */ new Date()).toISOString(),
+		latest: readCache()?.latest
+	};
+	try {
+		const controller = new AbortController();
+		const timer = setTimeout(() => controller.abort(), REFRESH_TIMEOUT_MS);
+		const res = await fetch(registryUrl(), {
+			headers: { accept: "application/json" },
+			signal: controller.signal
+		});
+		clearTimeout(timer);
+		if (res.ok) {
+			const { version } = await res.json();
+			if (version) cache.latest = version;
+		}
+	} catch {}
+	writeCache(cache);
+}
+//#endregion
+export { runRefresh as i, REFRESH_ENV as n, notifyOfUpdate as r, PACKAGE_NAME as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediamonks/canopy-cli",
-  "version": "0.0.1",
+  "version": "0.2.0",
   "description": "Canopy CLI — create, develop and deploy Canopy projects.",
   "bin": {
     "canopy": "./dist/index.mjs"
@@ -28,7 +28,7 @@
     "vite-plus": "0.2.5"
   },
   "scripts": {
-    "build": "vp pack",
+    "build": "vp pack && node ./scripts/sync-templates.mjs",
     "dev": "vp pack --watch",
     "test": "vp test",
     "check": "vp check"

package/dist/api-BEY4O4ap.mjs

@@ -1,36 +0,0 @@
-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/dev-Bvy21srH.mjs

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