@mediamonks/canopy-cli 0.7.32 → 0.7.34

package/dist/browse-Dycwj0V_.mjs

@@ -0,0 +1,89 @@
+import { d as tryResolveProject, n as siteConfig } from "./site-DM2J10CB.mjs";
+import { i as apiRequest, t as ApiError } from "./api-C4rMhE7i.mjs";
+import { defineCommand } from "citty";
+//#region src/browse.ts
+/**
+* canopy browse — a one-time sign-in link to a project for an agent's
+* browser (agent-browse-sessions). Opening it within a minute gives that
+* browser an hour on this one project and channel, as the signed-in Monk;
+* nothing else on Canopy. The link is the only thing printed: no cookie, no
+* token, nothing written to disk, and no browser opened (that is `canopy open`).
+*/
+var BrowseError = class extends Error {
+	name = "BrowseError";
+};
+/** The control plane's refusal, in words that say what to do about it. */
+function explainBrowseRefusal(code, slug, detail) {
+	switch (code) {
+		case "members_only": return `${slug} is limited to its collaborators — ask the owner to add you.`;
+		case "project_not_found": return `There is no project ${slug} on this site — check the slug and --profile.`;
+		case "project_paused": return `${slug} is paused.`;
+		case "project_moved": return `${slug} has moved${detail ? ` (${detail})` : ""}.`;
+		case "staging_not_enabled": return `${slug} has no staging channel yet — drop --staging, or create it with \`canopy deploy --staging\`.`;
+		case "invalid_path": return "--path must be a page on the project, starting with / (for example /settings).";
+		case "cli_session_required": return "Browse links need your own CLI sign-in, not a deploy token — run `canopy login`.";
+		case "not_configured": return "This site has no public project hostnames, so it can't hand out browse links.";
+		default: return detail ? `${code}: ${detail}` : code;
+	}
+}
+const browseCommand = defineCommand({
+	meta: {
+		name: "browse",
+		description: "Print a one-time sign-in link to a project for an agent's browser"
+	},
+	args: {
+		slug: {
+			type: "positional",
+			description: "Project slug (defaults to canopy.json in the current directory)",
+			required: false
+		},
+		staging: {
+			type: "boolean",
+			default: false,
+			description: "Link to the staging channel instead of live"
+		},
+		path: {
+			type: "string",
+			description: "Page to land on after signing in (default /)"
+		},
+		json: {
+			type: "boolean",
+			default: false,
+			description: "Print only { url, expires_at } as JSON"
+		}
+	},
+	async run({ args }) {
+		try {
+			const slug = tryResolveProject({ project: args.slug }).slug;
+			if (!slug) throw new BrowseError("No project named — pass a slug (`canopy browse <slug>`) or run from a project directory.");
+			if (process.env["CANOPY_DEPLOY_TOKEN"]) throw new BrowseError("Browse links use your own sign-in, not a deploy token — unset CANOPY_DEPLOY_TOKEN and run `canopy login`.");
+			if (!siteConfig().token) throw new BrowseError("Not signed in to this site — run `canopy login` first.");
+			let link;
+			try {
+				link = await apiRequest("POST", `/projects/${slug}/browse-ticket`, {
+					channel: args.staging ? "staging" : "live",
+					...args.path !== void 0 && { path: args.path }
+				});
+			} catch (err) {
+				if (err instanceof ApiError && err.status !== 401) throw new BrowseError(explainBrowseRefusal(err.code, slug, err.detail));
+				throw err;
+			}
+			if (args.json) {
+				process.stdout.write(`${JSON.stringify({
+					url: link.url,
+					expires_at: link.expires_at
+				})}\n`);
+				return;
+			}
+			console.log(`\n  ${link.url}\n`);
+			console.log("  Open it within a minute; it works once. The browser that opens it is signed in to");
+			console.log(`  ${slug}${args.staging ? " (staging)" : ""} as you for an hour, and to nothing else on Canopy.\n`);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			process.stderr.write(`canopy browse: ${message}\n`);
+			process.exitCode = 1;
+		}
+	}
+});
+//#endregion
+export { browseCommand };

package/dist/{dev-CkhBnSlv.mjs → dev-CGSIY1-y.mjs}

@@ -2,7 +2,7 @@ import { a as projectDirArgs, c as resolveProject, i as projectDialect, n as sit
 import { i as apiRequest, o as withContext, t as ApiError } from "./api-C4rMhE7i.mjs";
 import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
 import { r as readMigrationFiles } from "./migrations-Czlcddyz.mjs";
-import { r as stampWorkerHeaders } from "./src-BkACMkol.mjs";
+import { r as stampWorkerHeaders } from "./src-DE37PKho.mjs";
 import { n as writeDevServerRecord } from "./dev-server-file-Dk9pk4AR.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
@@ -40,7 +40,7 @@ async function workerPlugin(flags, slug) {
 		console.log(`note: canopy.json points "worker" at ${entry}, which does not exist — skipping.`);
 		return;
 	}
-	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-CaCsGBkn.mjs");
+	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-JbLEXmVg.mjs");
 	const secrets = readDevVars(flags.dir);
 	const email = siteConfig().email;
 	const plugin = workerDevPlugin({
@@ -225,7 +225,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-DAYCNUyz.mjs");
+		const { fetchProjectDump } = await import("./local-qR8CBseB.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -240,7 +240,7 @@ async function devLocal(flags, slug) {
 		const reason = err instanceof ApiError ? err.explain().why : String(err);
 		console.log(`Note: ai/services will be unavailable — could not reach the platform (${reason}).`);
 	}
-	const { createSandbox } = await import("./local-DAYCNUyz.mjs");
+	const { createSandbox } = await import("./local-qR8CBseB.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),

package/dist/dev-DO6Eso4L.mjs

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

package/dist/{dev-worker-CaCsGBkn.mjs → dev-worker-JbLEXmVg.mjs}

@@ -1,4 +1,4 @@
-import { n as redactCanopyCredentials, r as stampWorkerHeaders, t as CALLER_HEADER } from "./src-BkACMkol.mjs";
+import { n as redactCanopyCredentials, r as stampWorkerHeaders, t as CALLER_HEADER } from "./src-DE37PKho.mjs";
 import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 //#region src/dev-worker.ts

package/dist/docs/agent-browsing.md

@@ -0,0 +1,58 @@
+---
+title: Let your agent browse a project
+description: Give an AI agent's browser a short sign-in to one project, so it can look at and click through your app as you.
+---
+
+Coding agents often need to see the app they're working on: check that a page renders, click through a flow, or read what a screen shows. Every Canopy project sits behind the Monks sign-in, which an agent can't get through on its own.
+
+`canopy browse` gives the agent a way in that doesn't involve handing over your own browser session:
+
+```bash
+canopy browse my-app --json
+```
+
+It prints a one-time link. Whatever browser opens it is signed in to **my-app**, as you, for **an hour**, and to nothing else on Canopy.
+
+## What the agent gets
+
+- **One project, one channel.** The live site, or staging with `--staging`. The browser is not signed in to your other projects, or to the dashboard.
+- **You.** The app sees you as the visitor, exactly as when you open it yourself. Your backend's `env.USER` is you, and data you can see, the agent can see. On a collaborators-only project you have to be a collaborator.
+- **An hour.** After that the agent meets the sign-in page and can run `canopy browse` again.
+- **Marked as an agent.** Your backend can tell the request came from an agent: `mcpCaller(request, env).agent` from `@mediamonks/canopy/mcp` is `true`.
+
+The link itself works **once**, within **a minute**. Opening it a second time shows a page saying to run `canopy browse` again.
+
+## Using it from different tools
+
+**Playwright, or a browser tool in your agent:** open the URL. The browser is redirected to the page and stays signed in.
+
+```ts
+await page.goto(url); // lands on the project, signed in
+```
+
+**curl:** keep the cookie in a jar and follow the redirect.
+
+```bash
+curl -c jar.txt -L "$(canopy browse my-app --json | jq -r .url)"
+curl -b jar.txt https://my-app.canopy.website/api/notes
+```
+
+**A specific page:** `canopy browse my-app --path /settings` lands there directly.
+
+## Stopping it
+
+The agent's session ends when the hour is up. It also ends early if you:
+
+- run `canopy logout`,
+- revoke that CLI sign-in on your Account page in the dashboard, or
+- sign out everywhere.
+
+If you lose access to a collaborators-only project, the agent loses it too.
+
+## Good to know
+
+- Your project's backend needs a redeploy after this feature shipped before an agent can call its `/api/*` routes. Until then those calls answer "redeploy required", while pages still load.
+- The feedback widget doesn't appear for agents.
+- Never give an agent your own browser session cookie. It opens every project and the dashboard, as you.
+
+See also [canopy browse](https://docs.canopy.website/cli/browse), and [Agent tools](https://docs.canopy.website/guides/agent-tools) for letting agents call your backend directly.

package/dist/docs/cli-browse.md

@@ -0,0 +1,48 @@
+---
+title: canopy browse
+description: Print a one-time sign-in link that lets an agent's browser open a project as you.
+---
+
+`canopy browse` prints a link for an AI agent's browser: Playwright, a browser tool in Claude or Cursor, or plain `curl`. Opening the link signs that browser in to **one project**, as you, for **one hour**. It reaches nothing else on Canopy: no other projects, and not the dashboard.
+
+Read [Let your agent browse a project](https://docs.canopy.website/guides/agent-browsing) for the full picture.
+
+## Usage
+
+```bash
+canopy browse [slug] [--staging] [--path <page>] [--json]
+```
+
+## Arguments & flags
+
+- `[slug]` — the project. Defaults to the `canopy.json` in the current directory.
+- `--staging` — link to the project's [staging channel](https://docs.canopy.website/guides/staging) instead of the live site.
+- `--path <page>` — the page to land on after signing in, such as `/settings`. Defaults to `/`.
+- `--json` — print only `{ "url", "expires_at" }`, for an agent to read.
+
+The site comes from the active profile, as for every command (`--profile staging` links to the project on the staging site).
+
+## How it works
+
+The command uses your `canopy login` sign-in to ask Canopy for a link to the project, under the same rules as opening it yourself. Collaborators-only projects only give links to collaborators.
+
+- The link **works once** and **expires after a minute**. Run the command again for a new one.
+- The browser that opens it is signed in to that project and channel for an hour. After that it sees the sign-in page again.
+- Running `canopy logout`, revoking the CLI sign-in on your Account page, or signing out everywhere also signs the agent out.
+- The command never opens a browser itself (that's [canopy open](https://docs.canopy.website/cli/open)), never prints a cookie, and saves nothing.
+
+## Examples
+
+```bash
+canopy browse my-app --json
+```
+
+Prints `{"url":"https://my-app.…/__canopy/agent-login?ticket=…","expires_at":"…"}`. Hand the URL to your agent's browser.
+
+```bash
+canopy browse --staging --path /admin
+```
+
+A link to the staging channel of the project in this folder, landing on `/admin`.
+
+See also [canopy mcp](https://docs.canopy.website/cli/mcp), which lets agents call your project's backend as tools instead of using its pages.

package/dist/docs/cli-create.md

@@ -19,6 +19,7 @@ canopy create existing-app --no-scaffold  # register only, no files written
 - `--slug <slug>` — the URL slug; the project will live at `https://<slug>.<site-domain>`. Lowercase letters, digits and dashes only. Defaults to a slugified version of the name (prompted on a TTY).
 - `--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.
 - `--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-repo.md

@@ -0,0 +1,87 @@
+---
+title: canopy repo
+description: Create, clone and set up the project's git repository on Canopy.
+---
+
+`canopy repo` manages the project's git repository. A project has at most one: a
+Canopy repository, which Canopy keeps for it, or its own GitHub repository.
+Once a folder is set up, you use plain git. The CLI signs git in on every push
+and pull, so you never handle a password or token.
+
+## Usage
+
+```bash
+canopy repo show [--json]
+canopy repo create
+canopy repo clone <slug> [folder]
+canopy repo connect
+canopy repo delete [--yes]
+```
+
+## Arguments & flags
+
+`show`, `create`, `connect` and `delete` 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`.
+
+- `show` — whether the project has a repository, and if so its remote, when it
+  was created and when it was last pushed to.
+  - `--json` — the same as JSON, for scripts and agents.
+- `create` — create the project's Canopy repository. Owners, editors and
+  platform admins can. Run it in the project's folder and the folder is set up
+  too.
+- `clone <slug> [folder]` — clone the project's repository into a new folder
+  (the slug by default), ready to push.
+- `connect` — set up an existing folder.
+  - If the folder isn't a git repository yet, it is initialised on branch `main`.
+  - If it has no `origin`, the Canopy repository becomes `origin`.
+  - If `origin` points somewhere else, the Canopy repository is added as
+    `canopy`.
+- `delete` — delete the repository and all its history. Owner only. Asks you to
+  type the slug.
+  - `--yes` — skip that question.
+
+## How it works
+
+Setting up a folder (`create`, `clone`, `connect`) does two things:
+
+1. It points a remote at the project's repository.
+2. It registers the CLI as git's credential helper for that one repository.
+
+Nothing secret is written into the folder or its git settings. On each push or
+pull, git asks the CLI for credentials. The CLI exchanges your `canopy login`
+for a short-lived token that only works for this repository, keeps it in
+`~/.canopy` for up to an hour, and gets a new one when needed. `canopy logout`
+throws them away.
+
+Pushing doesn't deploy. Run `canopy deploy` for that.
+
+## Examples
+
+```bash
+canopy repo create
+git add -A && git commit -m "First version" && git push -u origin main
+```
+
+Creates the repository for the project in this folder and pushes the code.
+
+```bash
+canopy repo clone my-tool
+```
+
+Clones a teammate's project into `./my-tool`, ready to push.
+
+```bash
+canopy repo show --json
+```
+
+```json
+{
+  "kind": "canopy",
+  "remote": "https://monks.ghe.com/canopy/my-tool.git",
+  "created_at": "2026-10-21T09:12:00Z",
+  "last_push_at": "2026-10-21T09:15:42Z"
+}
+```
+
+Read the [git guide](https://docs.canopy.website/guides/git) for the bigger picture.

package/dist/docs/getting-started.md

@@ -93,6 +93,9 @@ Then open the live site:
 canopy open
 ```
 
+Want your code in git too, without a GitHub account? `canopy repo create` gives
+the project a repository on Canopy — see [Keep your code in git](https://docs.canopy.website/guides/git).
+
 ## Where to go next
 
 Everything the CLI can do is documented and available offline. List the topics:

package/dist/docs/git.md

@@ -0,0 +1,86 @@
+---
+title: Keep your code in git
+description: Give your project a git repository on Canopy — history, backup and sharing, no GitHub account needed.
+---
+
+Every project can have one git repository. If you already use GitHub, keep using
+it. If you don't have a GitHub account, Canopy can keep a private repository for
+your project instead. Your code then has history and a backup, and teammates and
+their agents can pick it up.
+
+A Canopy repository is for storing code. Pushing to it doesn't deploy anything —
+`canopy deploy` still does that.
+
+## Create one
+
+From your project folder:
+
+```bash
+canopy repo create
+```
+
+That creates the repository and sets up the folder, so from then on it is plain
+git:
+
+```bash
+git add -A
+git commit -m "First version"
+git push -u origin main
+```
+
+New projects can get one straight away with `canopy create my-tool --repo`. You
+can also create one from the dashboard, on the project's **Deploys** tab.
+
+## Work on it from another machine (or hand it to a teammate)
+
+Anyone on the project can clone it:
+
+```bash
+canopy repo clone my-tool
+```
+
+Already have the code in a folder? Set that folder up instead:
+
+```bash
+canopy repo connect
+```
+
+If the folder already pushes somewhere else (say your own GitHub), that stays
+`origin` and the Canopy repository is added as a second remote called `canopy`.
+
+## Signing in
+
+You never type a password or paste a token. The Canopy CLI signs git in for you
+on every push and pull, using your `canopy login`. When that sign-in expires, git
+stops and tells you to run `canopy login` again.
+
+Who can do what follows the project's members:
+
+- Owners and editors can pull and push.
+- Platform admins can pull.
+- Nobody else gets in.
+
+Remove someone from the project and they can no longer push or pull, even from
+a copy they already cloned.
+
+## Git apps (GitHub Desktop, VS Code, Tower, …)
+
+Set the folder up once with `canopy repo clone` or `canopy repo connect` in a
+terminal. After that, git apps that use the git installed on your computer push
+and pull as usual. Apps that bring their own git or ask for a password can't
+sign in to a Canopy repository; use the terminal for those.
+
+## Good to know
+
+- **Keep secrets out.** Files like `.env` and `.dev.vars` are ignored by the
+  project templates; secrets belong in `canopy secrets`.
+- **There is no branch protection.** Anyone who can push can rewrite history, so
+  avoid force-pushes on `main`.
+- **Deleting is for good.** `canopy repo delete` (owner only) removes the
+  repository and all its history. Deleting the project deletes its repository
+  too.
+- **Moving to your own GitHub later** is ordinary git: create an empty
+  repository there, then `git remote add github <its url>` and
+  `git push github --all`.
+
+See the [`canopy repo` reference](https://docs.canopy.website/cli/repo) for every command and flag.

package/dist/docs/index.json

@@ -67,11 +67,21 @@
           "title": "CI and deploy tokens",
           "summary": "Push-to-main deploys using a project-scoped deploy token."
         },
+        {
+          "slug": "git",
+          "title": "Keep your code in git",
+          "summary": "Give your project a git repository on Canopy — history, backup and sharing, no GitHub account needed."
+        },
         {
           "slug": "agent-tools",
           "title": "Agent tools (MCP)",
           "summary": "Let AI agents like Claude Code and Cursor use your project's backend as tools — as the person running them."
         },
+        {
+          "slug": "agent-browsing",
+          "title": "Let your agent browse a project",
+          "summary": "Give an AI agent's browser a short sign-in to one project, so it can look at and click through your app as you."
+        },
         {
           "slug": "porting-nextjs",
           "title": "Porting a Next.js app",
@@ -251,6 +261,11 @@
           "title": "canopy token",
           "summary": "Create, list, and revoke project-scoped deploy tokens for CI and push-to-main deploys."
         },
+        {
+          "slug": "cli-repo",
+          "title": "canopy repo",
+          "summary": "Create, clone and set up the project's git repository on Canopy."
+        },
         {
           "slug": "cli-egress",
           "title": "canopy egress",
@@ -301,6 +316,11 @@
           "title": "canopy open",
           "summary": "Open the deployed project in your browser."
         },
+        {
+          "slug": "cli-browse",
+          "title": "canopy browse",
+          "summary": "Print a one-time sign-in link that lets an agent's browser open a project as you."
+        },
         {
           "slug": "cli-docs",
           "title": "canopy docs",

package/dist/{docs-CtNH5kbN.mjs → docs-Cdoh5sMW.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-YGjjin4p.mjs";
+import { t as version } from "./package-Doigafvd.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-C_jSc1Kz.mjs";

package/dist/{feedback-_L3vqktY.mjs → feedback-vvysW6iw.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-YGjjin4p.mjs";
+import { t as version } from "./package-Doigafvd.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-C4rMhE7i.mjs";
 import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-YGjjin4p.mjs";
+import { t as version } from "./package-Doigafvd.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";
@@ -20,6 +20,7 @@ import { defineCommand, runMain } from "citty";
 *   ai models             the site's AI models and auto/* aliases
 *   mcp add|serve         a project's tools for AI agents (docs/49)
 *   open                  open the deployed project / dashboard   [phase 1]
+*   browse                one-time sign-in link for an agent's browser
 */
 if (process.env["CANOPY_UPDATE_REFRESH"] === "1") {
 	await runRefresh();
@@ -62,14 +63,14 @@ const main = defineCommand({
 		description: "canopy — create and deploy vibecoded projects"
 	},
 	subCommands: {
-		login: () => import("./login-B-m-i8uu.mjs").then((m) => m.loginCommand),
-		whoami: () => import("./login-B-m-i8uu.mjs").then((m) => m.whoamiCommand),
-		logout: () => import("./login-B-m-i8uu.mjs").then((m) => m.logoutCommand),
-		create: () => import("./projects-CN2YhCZn.mjs").then((m) => m.createCommand),
-		init: () => import("./projects-CN2YhCZn.mjs").then((m) => m.initCommand),
-		projects: () => import("./projects-CN2YhCZn.mjs").then((m) => m.projectsCommand),
-		delete: () => import("./projects-CN2YhCZn.mjs").then((m) => m.deleteCommand),
-		dev: () => import("./dev-MoHHjQh1.mjs").then((m) => m.devCommand),
+		login: () => import("./login-D0J5s_Ex.mjs").then((m) => m.loginCommand),
+		whoami: () => import("./login-D0J5s_Ex.mjs").then((m) => m.whoamiCommand),
+		logout: () => import("./login-D0J5s_Ex.mjs").then((m) => m.logoutCommand),
+		create: () => import("./projects-DQAhCZm8.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-DQAhCZm8.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-DQAhCZm8.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-DQAhCZm8.mjs").then((m) => m.deleteCommand),
+		dev: () => import("./dev-DO6Eso4L.mjs").then((m) => m.devCommand),
 		deploy: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.deployCommand),
 		promote: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.promoteCommand),
 		staging: () => import("./staging-BZVty57b.mjs").then((m) => m.stagingCommand),
@@ -79,19 +80,21 @@ const main = defineCommand({
 		egress: () => import("./egress-If_Gsx_M.mjs").then((m) => m.egressCommand),
 		secrets: () => import("./secrets-BSEjZnxg.mjs").then((m) => m.secretsCommand),
 		schedule: () => import("./schedule-C5lMf3ny.mjs").then((m) => m.scheduleCommand),
-		feedback: () => import("./feedback-_L3vqktY.mjs").then((m) => m.feedbackCommand),
+		feedback: () => import("./feedback-vvysW6iw.mjs").then((m) => m.feedbackCommand),
 		db: () => import("./db-BB6O6085.mjs").then((m) => m.dbCommand),
 		usage: () => import("./usage-CUYrWxv0.mjs").then((m) => m.usageCommand),
 		ai: () => import("./ai-DHLnyqfq.mjs").then((m) => m.aiCommand),
 		open: () => import("./open-DcaQKi1v.mjs").then((m) => m.openCommand),
-		docs: () => import("./docs-CtNH5kbN.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-CM7R-4Bq.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-ChcSZW8i.mjs").then((m) => m.upgradeCommand),
+		browse: () => import("./browse-Dycwj0V_.mjs").then((m) => m.browseCommand),
+		docs: () => import("./docs-Cdoh5sMW.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-DfSAZ2cW.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-DCQ3NzoL.mjs").then((m) => m.upgradeCommand),
 		logs: () => import("./logs-DQQOawOG.mjs").then((m) => m.logsCommand),
-		mcp: () => import("./mcp-RcN17Z2v.mjs").then((m) => m.mcpCommand)
+		mcp: () => import("./mcp-OR_ashGC.mjs").then((m) => m.mcpCommand),
+		repo: () => import("./repo-1RQ1vBMv.mjs").then((m) => m.repoCommand)
 	}
 });
-const quiet = process.argv[2] === "mcp" && process.argv[3] === "serve";
+const quiet = process.argv[2] === "mcp" && process.argv[3] === "serve" || process.argv[2] === "repo" && process.argv[3] === "credential";
 if (process.argv[2] !== "upgrade" && !quiet) notifyOfUpdate(version);
 if (!quiet && process.argv[2] && process.argv[2] !== "--help" && process.argv[2] !== "-h") console.error(siteHeaderLine(version));
 await runMain(main);

package/dist/{local-DAYCNUyz.mjs → local-qR8CBseB.mjs}

@@ -1,6 +1,6 @@
 import { n as apiDataRequest } from "./api-C4rMhE7i.mjs";
-import { a as dbRouter, i as realtimeRouter, o as META_COLUMNS, s as blobRouter } from "./src-BkACMkol.mjs";
-import { i as rewriteApiPath } from "./dev-CkhBnSlv.mjs";
+import { a as dbRouter, i as realtimeRouter, o as META_COLUMNS, s as blobRouter } from "./src-DE37PKho.mjs";
+import { i as rewriteApiPath } from "./dev-CGSIY1-y.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";

package/dist/{login-B-m-i8uu.mjs → login-D0J5s_Ex.mjs}

@@ -1,5 +1,6 @@
 import { _ as writeConfigFile, f as clearAllProfileTokens, g as upsertProfileAuth, h as setActiveProfile, m as readConfigFile, n as siteConfig, p as listBakedProfiles, v as getBakedProfile, y as isProfileId } from "./site-DM2J10CB.mjs";
 import { n as openBrowser, r as reportErrors } from "./ui-C_jSc1Kz.mjs";
+import { n as clearRepoTokenCache } from "./repo-credential-CNDRM-tG.mjs";
 import { defineCommand } from "citty";
 import { hostname } from "node:os";
 import * as p from "@clack/prompts";
@@ -98,8 +99,9 @@ const logoutCommand = defineCommand({
 			if (!result.ok) failed.push(`${id} (${result.error})`);
 		}
 		clearAllProfileTokens();
+		clearRepoTokenCache();
 		if (args.local) {
-			console.log("Logged out locally — tokens removed from ~/.canopy/config.json but still valid on the platform until they expire. Revoke them from the dashboard's Account page.");
+			console.log("Logged out locally — tokens removed from ~/.canopy but still valid on the platform until they expire (git repository tokens within the hour). Revoke them from the dashboard's Account page.");
 			return;
 		}
 		if (failed.length === 0) {

package/dist/{mcp-RcN17Z2v.mjs → mcp-OR_ashGC.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-YGjjin4p.mjs";
+import { t as version } from "./package-Doigafvd.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-C4rMhE7i.mjs";
 import { t as liveDevServer } from "./dev-server-file-Dk9pk4AR.mjs";

package/dist/{package-YGjjin4p.mjs → package-Doigafvd.mjs}

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

package/dist/{projects-CN2YhCZn.mjs → projects-DQAhCZm8.mjs}

@@ -1,6 +1,7 @@
 import { n as siteConfig, s as projectUrl, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
 import { i as apiRequest } from "./api-C4rMhE7i.mjs";
 import { a as unwrap, i as requireTty, r as reportErrors } from "./ui-C_jSc1Kz.mjs";
+import { r as offerRepoOnCreate } from "./repo-Bb9ntNa4.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { join, relative, resolve, sep } from "node:path";
@@ -105,6 +106,11 @@ const createCommand = defineCommand({
 			type: "boolean",
 			description: "Scaffold ./<slug>/ from the starter template",
 			negativeDescription: "Only register — no files written"
+		},
+		repo: {
+			type: "boolean",
+			description: "Also create a git repository for the project on Canopy",
+			negativeDescription: "Don't create a git repository (no question asked)"
 		}
 	},
 	run: reportErrors("create", async ({ args }) => {
@@ -166,14 +172,20 @@ const createCommand = defineCommand({
 				...tryReadCanopyJson(targetDir),
 				slug
 			});
+			const remote = await offerRepoOnCreate(slug, targetDir, args.repo);
 			const steps = [
 				`cd ${slug}`,
 				...template.needsInstall ? ["npm install"] : [],
+				...remote ? [`git add -A && git commit -m "Initial commit" && git push -u ${remote} main`] : [],
 				"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(existsSync(join(process.cwd(), "canopy.json")) ? "Registered without scaffolding — the existing canopy.json was left unchanged." : "Registered without scaffolding — add a canopy.json to deploy an existing app.");
+		} else {
+			const remote = await offerRepoOnCreate(slug, process.cwd(), args.repo);
+			if (remote) p.log.info(`This folder pushes to the project's git repository as "${remote}".`);
+			p.outro(existsSync(join(process.cwd(), "canopy.json")) ? "Registered without scaffolding — the existing canopy.json was left unchanged." : "Registered without scaffolding — add a canopy.json to deploy an existing app.");
+		}
 	})
 });
 /** Empty enough to scaffold into: missing, or holding only dotfiles (.git, .agents…). */