@mediamonks/canopy-cli 0.7.37 → 0.7.38

package/dist/docs/cli-create.md

@@ -11,6 +11,7 @@ description: Register a new project on Canopy and scaffold it locally from a sta
 canopy create                             # fully interactive
 canopy create "My Portfolio" --slug my-portfolio --template spa
 canopy create existing-app --no-scaffold  # register only, no files written
+canopy create "My Retro" --from retro-board  # start from a template
 ```
 
 ## Arguments & flags
@@ -20,6 +21,7 @@ canopy create existing-app --no-scaffold  # register only, no files written
 - `--template <id>` — starter to scaffold: `static` (plain HTML/CSS/JS, no build step, untyped SDK from the platform — simplest apps), `spa` (Vite + React + TypeScript with the typed SDK from npm — best for real SDK use or growth), or `worker` (`spa` plus a backend worker in `worker/` — for server-side code: secrets, schedules, calling external APIs). A picker appears when omitted on a TTY; `static` is the default otherwise.
 - `--scaffold` / `--no-scaffold` — whether to write `./<slug>/` from the template. When neither is given, the CLI scaffolds unless the current directory already has a `canopy.json` (in which case it assumes you're registering an existing app and only registers).
 - `--repo` / `--no-repo` — also create a git repository for the project on Canopy and set up the new folder to push to it (see [`canopy repo`](https://docs.canopy.website/cli/repo)). When neither is given, an interactive run asks (default no) on sites that offer repositories; non-interactive runs create none.
+- `--from <template>` — start from a template project instead of a starter: the new project gets a copy of the template's code in its own git repository, cloned into `./<slug>/`, plus the setup the code needs. The CLI shows what comes along and asks before creating. `--template`, `--scaffold` and `--repo` don't apply. See [Start from a template](https://docs.canopy.website/guides/templates).
 - `--profile <site>` — global flag (or `CANOPY_PROFILE`): which site to create the project on. The chosen profile is pinned into the scaffolded `canopy.json`.
 
 ## How it works

package/dist/docs/cli-projects.md

@@ -10,12 +10,14 @@ description: List your Canopy projects with their status, role, and live URLs.
 ```bash
 canopy projects
 canopy projects --all
+canopy projects --templates
 canopy --profile staging projects
 ```
 
 ## Arguments & flags
 
 - `--all` — include projects you can't edit. By default the list shows only projects where you're an owner or editor (admins always see everything, since they can edit everything).
+- `--templates` — list the templates anyone can start a project from, with their owners. See [Start from a template](https://docs.canopy.website/guides/templates).
 - `--profile <site>` — global flag (or `CANOPY_PROFILE`): each site has its own project registry, so listing on `staging` shows a completely different set than `main`.
 
 ## Details

package/dist/docs/cli-secrets.md

@@ -25,7 +25,8 @@ target directory, or `--project <slug>` to override — and honor the global
 `--profile <site>` / `CANOPY_PROFILE`.
 
 - `list` — print the secret names and when each was last set. Values are
-  never shown.
+  never shown. For a project started from a template, names it still needs a
+  value for are listed as missing.
 - `set <name>` — store a value. Names are `UPPER_SNAKE_CASE`, up to 64
   characters. The value comes from **stdin** when piped (one trailing newline
   is trimmed, so `echo` works too), from `--from-env <VAR>` to read an

package/dist/docs/cli-template.md

@@ -0,0 +1,47 @@
+---
+title: canopy template
+description: Offer a project as a template, or see what a template gives a new project.
+---
+
+`canopy template` controls whether others can start a project from yours, and
+shows what a template gives a new project. To start from one, use
+[`canopy create --from`](https://docs.canopy.website/cli/create).
+
+## Usage
+
+```bash
+canopy template mark [--yes]
+canopy template unmark
+canopy template show <slug>
+```
+
+## Arguments & flags
+
+`mark` and `unmark` resolve the project the usual way: `canopy.json` in the
+target folder, or `--project <slug>`. All of them honour the global
+`--profile <site>` / `CANOPY_PROFILE`.
+
+- `mark` — let anyone on the site start a project from this one. Owner only.
+  The project needs a Canopy git repository with code pushed to it. Asks for
+  confirmation; `--yes` skips it in scripts. Warns when `canopy.json` names no
+  migrations folder, because new projects then start without any tables.
+- `unmark` — stop new projects starting from this one. Existing copies are not
+  affected.
+- `show <slug>` — what a new project gets from a template: the code, outbound
+  hosts, page settings, Google access, schedules (turned off) and secret names.
+
+## Examples
+
+```bash
+canopy template mark
+```
+
+Offers the project in this folder as a template.
+
+```bash
+canopy template show retro-board
+```
+
+Shows what `canopy create --from retro-board` would give you.
+
+Read [Start from a template](https://docs.canopy.website/guides/templates) for the bigger picture.

package/dist/docs/index.json

@@ -72,6 +72,11 @@
           "title": "Keep your code in git",
           "summary": "Give your project a git repository on Canopy — history, backup and sharing, no GitHub account needed."
         },
+        {
+          "slug": "templates",
+          "title": "Start from a template",
+          "summary": "Begin a project from someone else's working one — a copy of their code and setup, never their data."
+        },
         {
           "slug": "agent-tools",
           "title": "Agent tools (MCP)",
@@ -266,6 +271,11 @@
           "title": "canopy repo",
           "summary": "Create, clone and set up the project's git repository on Canopy."
         },
+        {
+          "slug": "cli-template",
+          "title": "canopy template",
+          "summary": "Offer a project as a template, or see what a template gives a new project."
+        },
         {
           "slug": "cli-egress",
           "title": "canopy egress",

package/dist/docs/templates.md

@@ -0,0 +1,84 @@
+---
+title: Start from a template
+description: Begin a project from someone else's working one — a copy of their code and setup, never their data.
+---
+
+Some projects are worth starting from: a retro board, a feedback form, a small
+dashboard on an internal API. When the owner offers one as a **template**,
+anyone on Canopy can start a project of their own from it. You get a copy of
+the code and the setup the code needs, then change it however you like.
+
+Your copy is yours. Later changes to the template don't reach it, and nothing
+you do reaches the template.
+
+## Find one
+
+```bash
+canopy projects --templates
+canopy template show retro-board
+```
+
+`show` lists exactly what a new project gets. In the dashboard, switch on the
+**Templates** filter on the project list; each template has a **Use as
+template** button that shows the same list.
+
+## Start your project
+
+```bash
+canopy create "My Retro" --slug my-retro --from retro-board
+```
+
+Canopy creates the project, gives it its own git repository with the
+template's code in one fresh commit, and clones it into `./my-retro/`. It then
+tells you what is left, usually:
+
+```bash
+cd my-retro
+canopy secrets set OPENAI_KEY
+canopy deploy
+```
+
+The first deploy runs the template's migrations, so your database starts with
+its tables and nothing else.
+
+## What you get, and what you don't
+
+You get:
+
+- the code in the template's repository, as it is right now, without its
+  history;
+- its allowed outbound hosts and page settings;
+- the Google access it asks visitors for (restricted Google access stays off
+  until a Canopy admin unlocks it for your project);
+- its schedules, **turned off** — turn each one on when you're ready;
+- the **names** of its secrets, so you know what to fill in. `canopy secrets
+list` shows the ones still missing.
+
+You never get its data, stored files, secret values, members, client password,
+budgets, feedback or deploy history. Your project starts with the usual
+defaults for those.
+
+## Offer your project as a template
+
+Your project needs a Canopy git repository with your code pushed to it (see
+[Keep your code in git](https://docs.canopy.website/guides/git)). Then:
+
+```bash
+canopy template mark
+```
+
+or **Settings → Template** in the dashboard. Only the owner can do this.
+
+Before you do:
+
+- **Everyone on the site can copy the code.** Make sure the repository holds no
+  keys, passwords or client data.
+- **Put sample data in migrations.** The database never comes along, so any
+  starting rows belong in your migrations. Without a migrations folder, new
+  projects start with an empty database.
+- **Explain setup in the README.** It's the first thing people read in their
+  copy.
+
+`canopy template unmark` stops new copies. Projects already started from it
+are not affected. The template's Settings page shows how many projects started
+from it.

package/dist/{docs-DvCUaI1O.mjs → docs-T1nuu00A.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BY69Tjq_.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { n as siteConfig } from "./site-DM2J10CB.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
 import { r as reportErrors } from "./ui-CHfKV6lG.mjs";

package/dist/{feedback-CIjjiEaj.mjs → feedback-C5NKCOXQ.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BY69Tjq_.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { a as projectDirArgs, c as resolveProject, d as tryResolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
 import { a as apiUpload, i as apiRequest, r as apiDownload } from "./api-BPEYm9ts.mjs";
 import { r as reportErrors, t as formatDateTime } from "./ui-CHfKV6lG.mjs";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-BY69Tjq_.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { r as siteHeaderLine, t as setInvocationProfile } from "./site-DM2J10CB.mjs";
 import { a as notifyOfUpdate, o as runRefresh } from "./version-check-CcsA1QjI.mjs";
 import { defineCommand, runMain } from "citty";
@@ -66,10 +66,10 @@ const main = defineCommand({
 		login: () => import("./login-CtDWXICZ.mjs").then((m) => m.loginCommand),
 		whoami: () => import("./login-CtDWXICZ.mjs").then((m) => m.whoamiCommand),
 		logout: () => import("./login-CtDWXICZ.mjs").then((m) => m.logoutCommand),
-		create: () => import("./projects-DPGRI-SI.mjs").then((m) => m.createCommand),
-		init: () => import("./projects-DPGRI-SI.mjs").then((m) => m.initCommand),
-		projects: () => import("./projects-DPGRI-SI.mjs").then((m) => m.projectsCommand),
-		delete: () => import("./projects-DPGRI-SI.mjs").then((m) => m.deleteCommand),
+		create: () => import("./projects-Bm4oTodB.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-Bm4oTodB.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-Bm4oTodB.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-Bm4oTodB.mjs").then((m) => m.deleteCommand),
 		dev: () => import("./dev-D_qzeLng.mjs").then((m) => m.devCommand),
 		deploy: () => import("./deploy-CqCyry4o.mjs").then((m) => m.deployCommand),
 		promote: () => import("./deploy-CqCyry4o.mjs").then((m) => m.promoteCommand),
@@ -78,20 +78,21 @@ const main = defineCommand({
 		download: () => import("./deploy-CqCyry4o.mjs").then((m) => m.downloadCommand),
 		token: () => import("./token-BWnLsWLg.mjs").then((m) => m.tokenCommand),
 		egress: () => import("./egress-ButFsQ2N.mjs").then((m) => m.egressCommand),
-		secrets: () => import("./secrets-BQYaPSOT.mjs").then((m) => m.secretsCommand),
+		secrets: () => import("./secrets-BOKuWBYV.mjs").then((m) => m.secretsCommand),
 		schedule: () => import("./schedule-DdMq5eXC.mjs").then((m) => m.scheduleCommand),
-		feedback: () => import("./feedback-CIjjiEaj.mjs").then((m) => m.feedbackCommand),
+		feedback: () => import("./feedback-C5NKCOXQ.mjs").then((m) => m.feedbackCommand),
 		db: () => import("./db-CbqgjfYz.mjs").then((m) => m.dbCommand),
 		usage: () => import("./usage-Cqqvnzrf.mjs").then((m) => m.usageCommand),
 		ai: () => import("./ai-CjvrcBIz.mjs").then((m) => m.aiCommand),
 		open: () => import("./open-DXo60Ikf.mjs").then((m) => m.openCommand),
 		browse: () => import("./browse-CBelCgnW.mjs").then((m) => m.browseCommand),
-		docs: () => import("./docs-DvCUaI1O.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-B96cKy8K.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-SfxmPh3F.mjs").then((m) => m.upgradeCommand),
+		docs: () => import("./docs-T1nuu00A.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-3wOwhzDx.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-BJ2dWjCG.mjs").then((m) => m.upgradeCommand),
 		logs: () => import("./logs-BltUi4Gp.mjs").then((m) => m.logsCommand),
-		mcp: () => import("./mcp-DTUJV4FT.mjs").then((m) => m.mcpCommand),
-		repo: () => import("./repo-DvrIsubH.mjs").then((m) => m.repoCommand)
+		mcp: () => import("./mcp-BwLRcfqz.mjs").then((m) => m.mcpCommand),
+		repo: () => import("./repo-DlYX_1tN.mjs").then((m) => m.repoCommand),
+		template: () => import("./project-template-DdT0dqpn.mjs").then((m) => m.templateCommand)
 	}
 });
 const quiet = process.argv[2] === "mcp" && process.argv[3] === "serve" || process.argv[2] === "repo" && process.argv[3] === "credential";

package/dist/{mcp-DTUJV4FT.mjs → mcp-BwLRcfqz.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BY69Tjq_.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { d as tryResolveProject, l as stagingUrl, n as siteConfig, s as projectUrl } from "./site-DM2J10CB.mjs";
 import { i as apiRequest, t as ApiError } from "./api-BPEYm9ts.mjs";
 import { t as liveDevServer } from "./dev-server-file-Dk9pk4AR.mjs";

package/dist/{package-BY69Tjq_.mjs → package-CdDH35SE.mjs}

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

package/dist/project-template-BEr_tgIY.mjs

@@ -0,0 +1,125 @@
+import { a as projectDirArgs, c as resolveProject } from "./site-DM2J10CB.mjs";
+import { i as apiRequest, o as withContext } from "./api-BPEYm9ts.mjs";
+import { a as unwrap, i as requireTty, r as reportErrors } from "./ui-CHfKV6lG.mjs";
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+/** Plain words for the API's template errors. */
+const TEMPLATE_FIXES = {
+	template_not_found: "No template by that name on this site. `canopy projects --templates` lists the templates you can start from.",
+	template_empty: "The template's repository has no code yet. Ask its owner to push it first.",
+	template_too_large: `The template's files are larger than the 32 MiB a copy can hold. Ask its owner to remove large files from the repository.`,
+	repo_required: "A template needs a Canopy git repository. Create one with `canopy repo create`, push the code, then try again.",
+	repo_empty: "Push the project's code to its repository first, then try again.",
+	owner_only: "Only the project owner can make it a template, or stop it being one.",
+	repos_not_configured: "Templates need Canopy git repositories, which are not available on this site yet."
+};
+/** What the new project gets, one line each — shown before creating. */
+function describeCopy(copy) {
+	const lines = ["The code in its repository, as one fresh commit (no history)."];
+	if (copy.egress_mode === "open") lines.push("Outbound access: open (the backend may call any host).");
+	else if (copy.egress_allowlist.length) lines.push(`Outbound hosts allowed: ${copy.egress_allowlist.join(", ")}.`);
+	const loosened = [
+		!copy.csp_enabled && "Content-Security-Policy off",
+		copy.allow_framing && "other sites may frame the app",
+		copy.browser_db_access !== "full" && `browser database access: ${copy.browser_db_access}`,
+		!copy.feedback_widget && "feedback widget hidden"
+	].filter(Boolean);
+	if (loosened.length) lines.push(`Page settings: ${loosened.join("; ")}.`);
+	if (copy.google_bundles.length) lines.push(`Google access it asks visitors for: ${copy.google_bundles.join(", ")}.`);
+	if (copy.schedules.length) lines.push(`Schedules, turned off: ${copy.schedules.map((s) => `${s.name} (${s.cron})`).join(", ")}.`);
+	if (copy.secrets.length) lines.push(`Secret names to fill in (no values): ${copy.secrets.join(", ")}.`);
+	lines.push("Not copied: its data, files, members, password, budgets or history.");
+	return lines;
+}
+/** What is left to do once the project exists. */
+function nextSteps(slug, copy) {
+	const steps = [`cd ${slug}`];
+	for (const name of copy.secrets) steps.push(`canopy secrets set ${name}`);
+	steps.push("canopy deploy");
+	for (const s of copy.schedules) steps.push(`canopy schedule add ${s.name} "${s.cron}"   (to turn it on)`);
+	if (copy.google_restricted.length) steps.push(`Ask a Canopy admin to unlock restricted Google access (${copy.google_restricted.join(", ")}), then turn it on in the dashboard.`);
+	return steps;
+}
+function fetchTemplate(slug) {
+	return withContext(apiRequest("GET", `/projects/${slug}/template`), {
+		action: `read template ${slug}`,
+		fixes: TEMPLATE_FIXES
+	});
+}
+const templateCommand = defineCommand({
+	meta: {
+		name: "template",
+		description: "Offer a project as a template (mark, unmark, show)"
+	},
+	subCommands: {
+		mark: defineCommand({
+			meta: {
+				name: "mark",
+				description: "Let anyone on this site start a project from this one"
+			},
+			args: {
+				...projectDirArgs,
+				yes: {
+					type: "boolean",
+					description: "Skip the confirmation",
+					default: false
+				}
+			},
+			run: reportErrors("template mark", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				if (!args.yes) {
+					requireTty("pass --yes to confirm.");
+					p.log.info(`Everyone on this site will be able to start a project of their own with a copy of ${slug}'s current code in its repository, plus its setup (outbound hosts, page settings, schedule and secret names). Its data, secret values and members are never copied.`);
+					if (!unwrap(await p.confirm({
+						message: `Make ${slug} a template?`,
+						initialValue: false
+					}))) {
+						p.cancel("Not marked.");
+						return;
+					}
+				}
+				if ((await withContext(apiRequest("PUT", `/projects/${slug}/template`, { enabled: true }), {
+					action: `make ${slug} a template`,
+					fixes: TEMPLATE_FIXES
+				})).warnings.includes("no_migrations")) p.log.warn("canopy.json sets no \"migrations\", so new projects start with an empty database: none of its tables come along. Add migrations to the repository to fix that.");
+				p.log.success(`${slug} is a template. Others start from it with \`canopy create <name> --from ${slug}\`.`);
+			})
+		}),
+		unmark: defineCommand({
+			meta: {
+				name: "unmark",
+				description: "Stop new projects starting from this one"
+			},
+			args: { ...projectDirArgs },
+			run: reportErrors("template unmark", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				await withContext(apiRequest("PUT", `/projects/${slug}/template`, { enabled: false }), {
+					action: `stop ${slug} being a template`,
+					fixes: TEMPLATE_FIXES
+				});
+				p.log.success(`${slug} is no longer a template. Projects already started from it are not affected.`);
+			})
+		}),
+		show: defineCommand({
+			meta: {
+				name: "show",
+				description: "Show what a new project gets from a template"
+			},
+			args: { slug: {
+				type: "positional",
+				description: "Template slug",
+				required: true
+			} },
+			run: reportErrors("template show", async ({ args }) => {
+				const preview = await fetchTemplate(args.slug);
+				const t = preview.template;
+				console.log(`${t.name} (${t.slug}) — by ${t.owner.name} <${t.owner.email}>`);
+				if (t.description) console.log(t.description);
+				console.log("");
+				for (const line of describeCopy(preview.copies)) console.log(`- ${line}`);
+			})
+		})
+	}
+});
+//#endregion
+export { templateCommand as a, nextSteps as i, describeCopy as n, fetchTemplate as r, TEMPLATE_FIXES as t };

package/dist/project-template-DdT0dqpn.mjs

@@ -0,0 +1,2 @@
+import { a as templateCommand } from "./project-template-BEr_tgIY.mjs";
+export { templateCommand };

package/dist/{projects-DPGRI-SI.mjs → projects-Bm4oTodB.mjs}

@@ -1,7 +1,8 @@
 import { n as siteConfig, s as projectUrl, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
-import { i as apiRequest } from "./api-BPEYm9ts.mjs";
+import { i as apiRequest, o as withContext } from "./api-BPEYm9ts.mjs";
 import { a as unwrap, i as requireTty, r as reportErrors } from "./ui-CHfKV6lG.mjs";
-import { r as offerRepoOnCreate } from "./repo-CKIQrrHK.mjs";
+import { i as nextSteps, n as describeCopy, r as fetchTemplate, t as TEMPLATE_FIXES } from "./project-template-BEr_tgIY.mjs";
+import { i as offerRepoOnCreate, n as cloneProjectRepo } from "./repo-CE22HpqZ.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
@@ -111,6 +112,10 @@ const createCommand = defineCommand({
 			type: "boolean",
 			description: "Also create a git repository for the project on Canopy",
 			negativeDescription: "Don't create a git repository (no question asked)"
+		},
+		from: {
+			type: "string",
+			description: "Start from a template project: a copy of its code and setup (`canopy projects --templates`)"
 		}
 	},
 	run: reportErrors("create", async ({ args }) => {
@@ -134,6 +139,10 @@ const createCommand = defineCommand({
 			}
 		})).trim();
 		slug ||= slugify(name);
+		if (args.from) {
+			await createFromTemplate(name, slug, args.from);
+			return;
+		}
 		const scaffold = shouldScaffoldCreate(args.scaffold);
 		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(", ")}.`);
@@ -188,6 +197,45 @@ const createCommand = defineCommand({
 		}
 	})
 });
+/**
+* `canopy create --from` (project-templates): show what the new project
+* gets, create it with a copy of the template, clone it, list what's left.
+*/
+async function createFromTemplate(name, slug, from) {
+	const targetDir = resolve(slug);
+	if (existsSync(targetDir)) throw new Error(`Directory ./${slug} already exists — remove it, or pick another slug.`);
+	const preview = await fetchTemplate(from);
+	p.note(describeCopy(preview.copies).join("\n"), `From ${preview.template.name} (by ${preview.template.owner.name}), ${slug} gets`);
+	if (process.stdin.isTTY) {
+		if (!unwrap(await p.confirm({
+			message: `Create ${slug} from ${from}?`,
+			initialValue: true
+		}))) {
+			p.cancel("Nothing created.");
+			return;
+		}
+	}
+	const spin = p.spinner();
+	spin.start(`Creating ${slug} from ${from}…`);
+	let project;
+	try {
+		({project} = await withContext(apiRequest("POST", "/projects", {
+			slug,
+			name,
+			from
+		}), {
+			action: `create ${slug} from ${from}`,
+			fixes: TEMPLATE_FIXES
+		}));
+	} catch (err) {
+		spin.error("Create failed.");
+		throw err;
+	}
+	spin.stop(`Created ${project.name} — ${projectUrl(project.slug)}`);
+	await cloneProjectRepo(slug, targetDir);
+	p.note(nextSteps(slug, preview.copies).join("\n"), `Cloned into ./${slug}/ — next`);
+	p.outro(`Live URL (after first deploy): ${projectUrl(project.slug)}`);
+}
 /** Empty enough to scaffold into: missing, or holding only dotfiles (.git, .agents…). */
 function isEmptyish(dir) {
 	if (!existsSync(dir)) return true;
@@ -294,13 +342,31 @@ const projectsCommand = defineCommand({
 		name: "projects",
 		description: "List your projects"
 	},
-	args: { all: {
-		type: "boolean",
-		default: false,
-		description: "Include projects you can't edit"
-	} },
+	args: {
+		all: {
+			type: "boolean",
+			default: false,
+			description: "Include projects you can't edit"
+		},
+		templates: {
+			type: "boolean",
+			default: false,
+			description: "List the templates anyone can start a project from"
+		}
+	},
 	run: reportErrors("projects", async ({ args }) => {
 		const { projects, is_admin: isAdmin } = await apiRequest("GET", "/projects");
+		if (args.templates) {
+			const templates = projects.filter((project) => project.is_template);
+			if (templates.length === 0) {
+				console.log("No templates on this site yet.");
+				return;
+			}
+			const width = Math.max(...templates.map((project) => project.slug.length));
+			for (const project of templates) console.log(`${project.slug.padEnd(width)}  ${project.name}  (${project.owner_email})`);
+			console.log(`\nStart from one with \`canopy create <name> --from <template>\`.`);
+			return;
+		}
 		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}.`);

package/dist/{repo-CKIQrrHK.mjs → repo-CE22HpqZ.mjs}

@@ -268,20 +268,23 @@ const cloneCommand = defineCommand({
 		}
 	},
 	run: reportErrors("repo clone", async ({ args }) => {
-		const slug = args.slug;
-		const repo = requireCanopyRepo(slug, await fetchRepo(slug));
-		await requireGit();
-		const target = resolve(args.target ?? slug);
-		const code = await gitInteractive([
-			"clone",
-			...credentialConfig(repo.remote, currentProfile(), slug).flatMap(([key, values]) => values.flatMap((value) => ["-c", `${key}=${value}`])),
-			repo.remote,
-			target
-		]);
-		if (code !== 0) throw new Error(`git clone failed (exit ${code}).`);
-		p.log.success(`Cloned ${slug} into ${target}.`);
+		const target = await cloneProjectRepo(args.slug, resolve(args.target ?? args.slug));
+		p.log.success(`Cloned ${args.slug} into ${target}.`);
 	})
 });
+/** Clone a project's Canopy repository into `target`, credential helper included. */
+async function cloneProjectRepo(slug, target) {
+	const repo = requireCanopyRepo(slug, await fetchRepo(slug));
+	await requireGit();
+	const code = await gitInteractive([
+		"clone",
+		...credentialConfig(repo.remote, currentProfile(), slug).flatMap(([key, values]) => values.flatMap((value) => ["-c", `${key}=${value}`])),
+		repo.remote,
+		target
+	]);
+	if (code !== 0) throw new Error(`git clone failed (exit ${code}).`);
+	return target;
+}
 const deleteCommand = defineCommand({
 	meta: {
 		name: "delete",
@@ -420,4 +423,4 @@ async function offerRepoOnCreate(slug, dir, flag) {
 	}
 }
 //#endregion
-export { repoCommand as i, connectFolder as n, offerRepoOnCreate as r, cliInvocation as t };
+export { repoCommand as a, offerRepoOnCreate as i, cloneProjectRepo as n, connectFolder as r, cliInvocation as t };

package/dist/repo-DlYX_1tN.mjs

@@ -0,0 +1,2 @@
+import { a as repoCommand } from "./repo-CE22HpqZ.mjs";
+export { repoCommand };

package/dist/{secrets-BQYaPSOT.mjs → secrets-BOKuWBYV.mjs}

@@ -52,13 +52,14 @@ const secretsCommand = defineCommand({
 			args: { ...projectDirArgs },
 			run: reportErrors("secrets list", async ({ args }) => {
 				const { slug } = resolveProject(args);
-				const { secrets } = await apiRequest("GET", `/projects/${slug}/secrets`);
-				if (secrets.length === 0) {
+				const { secrets, missing = [] } = await apiRequest("GET", `/projects/${slug}/secrets`);
+				if (secrets.length === 0 && missing.length === 0) {
 					console.log(`No secrets set for ${slug} — add one with \`canopy secrets set NAME\`.`);
 					return;
 				}
-				const width = Math.max(...secrets.map((s) => s.key.length));
+				const width = Math.max(...secrets.map((s) => s.key.length), ...missing.map((m) => m.length));
 				for (const s of secrets) console.log(`${s.key.padEnd(width)}  updated ${formatDateTime(s.updated_at)}`);
+				for (const name of missing) console.log(`${name.padEnd(width)}  missing — set it with \`canopy secrets set ${name}\``);
 			})
 		}),
 		set: defineCommand({

package/dist/{skill-B96cKy8K.mjs → skill-3wOwhzDx.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-BY69Tjq_.mjs";
+import { t as version } from "./package-CdDH35SE.mjs";
 import { r as reportErrors } from "./ui-CHfKV6lG.mjs";
 import { defineCommand } from "citty";
 import { cpSync, existsSync, mkdirSync, rmSync, symlinkSync, writeFileSync } from "node:fs";

package/dist/{upgrade-SfxmPh3F.mjs → upgrade-BJ2dWjCG.mjs}

@@ -112,7 +112,7 @@ const upgradeCommand = defineCommand({
 		const spec = `${PACKAGE_NAME}@${args.version ?? "latest"}`;
 		const command = pmCommand(pm);
 		const cmd = installArgs(pm, spec);
-		const { skillInstalled } = await import("./skill-B96cKy8K.mjs");
+		const { skillInstalled } = await import("./skill-3wOwhzDx.mjs");
 		const { homedir } = await import("node:os");
 		const refreshGlobal = skillInstalled(homedir());
 		const refreshRepo = process.cwd() !== homedir() && skillInstalled(process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediamonks/canopy-cli",
-  "version": "0.7.37",
+  "version": "0.7.38",
   "description": "Canopy CLI — create, develop and deploy Canopy projects.",
   "bin": {
     "canopy": "./dist/index.mjs"

package/dist/repo-DvrIsubH.mjs

@@ -1,2 +0,0 @@
-import { i as repoCommand } from "./repo-CKIQrrHK.mjs";
-export { repoCommand };