@mediamonks/canopy-cli 0.7.5 → 0.7.7

package/dist/docs/platform-schedules.md

@@ -0,0 +1,90 @@
+---
+title: Schedules
+description: Run named cron jobs in your project's backend — configured in the dashboard, so you can change the cadence without redeploying.
+---
+
+Schedules let a project do things on a clock: send a daily digest, refresh a
+cache every hour, tick a counter every minute. You define **named jobs** in
+the dashboard, and the platform wakes your project's backend at the right
+times — your code only decides what each job does.
+
+> **Note:** Schedules need a project with a custom backend. Per-project backends run on the **main** site and
+> the **GCP pilot** site. On sites without backend support the Schedules section doesn't appear in
+> Settings, and the API answers `not_supported_on_target`.
+
+## Defining a schedule
+
+In the dashboard, open the project's **Settings → Schedules**. Each schedule
+has:
+
+- a **name** (like `daily-digest`) — this is what your code switches on;
+- a **cron expression** — standard 5-field cron, always in **UTC**;
+- an **enabled** toggle, so you can pause a job without deleting it.
+
+A project can have up to **5 schedules**, and the shortest interval is one
+minute. Each row also shows its last run and, if it failed, the error — so
+you can see at a glance whether a job is healthy.
+
+You can also trigger a schedule manually from the dashboard, which is the
+quickest way to test a handler without waiting for the clock.
+
+## Handling schedules in your code
+
+Your project's worker exports a `scheduled` handler next to its normal
+`fetch` handler, and switches on the job's name:
+
+```ts
+export default {
+  async fetch(request, env, ctx) {
+    return app.fetch(request, env, ctx);
+  },
+
+  async scheduled(event, env, ctx) {
+    switch (event.name) {
+      case "daily-digest":
+        await sendDigest(env);
+        break;
+      default:
+        console.warn("unknown schedule", event.name);
+    }
+  },
+};
+```
+
+`event.name` is the name you gave the schedule in the dashboard, `event.cron`
+is the expression that fired, and `event.scheduledTime` is when it fired.
+Inside the handler your code has the same environment as an HTTP request —
+secrets, the project database, and blob storage all work the same way.
+
+## Data access without a signed-in user
+
+A scheduled run has no browser session attached, but `canopy.db`, `canopy.blob`
+and `canopy.ai` still work: the platform seals a **project-scoped worker
+token** into your backend on every deploy, and calls through the platform
+fall back to it whenever the request carries no user credential. You don't
+configure or see this token — it's minted, rotated (every deploy replaces
+it), and revoked with the project automatically, and it only ever reaches
+your own project's data.
+
+The one thing that behaves differently is identity: `canopy.auth.user()`
+resolves with `kind: "worker"` and empty `id`/`email`/`name` — there is no
+one signed in during a cron tick, and your code should treat that as "no
+user", not as an error.
+
+## Why the name matters
+
+Switch on `event.name`, not on the cron string. The dashboard is the source
+of truth for _when_ a job runs, so you can change `daily-digest` from 6:00 to
+7:30 — or pause it — without touching code or redeploying. The name is the
+stable contract between the dashboard and your handler.
+
+## Things to know
+
+- **Cron runs as the project, not as a person.** Data access works (see
+  above), but there is no signed-in user — `auth.user()` answers with
+  `kind: "worker"` and no identity.
+- **All times are UTC.** `0 6 * * *` is 6:00 UTC, not local time.
+- **Failures are visible.** A run that throws records its error on the
+  schedule row in Settings, so silent breakage doesn't stay silent.
+
+- [Infrastructure](https://docs.canopy.website/guides/infrastructure) — What runs where — assets, backends, databases — across the Canopy sites.

package/dist/docs/platform-sites-and-profiles.md

@@ -0,0 +1,61 @@
+---
+title: Sites & profiles
+description: Canopy runs as more than one installation. Most people only ever use main — here's what the others are and how the CLI keeps them straight.
+---
+
+Canopy isn't a single installation: the same platform runs as a few separate
+**sites**, each with its own domain, its own projects, and its own data.
+Unless someone told you otherwise, **you're on `main` and can stop reading
+here** — the rest of this page explains what the other sites are for and how
+the CLI targets them.
+
+## The sites
+
+| Site        | Project URLs          | What it's for                                     |
+| ----------- | --------------------- | ------------------------------------------------- |
+| `main`      | `*.canopy.website`    | The real platform. Your projects live here.       |
+| `staging`   | `*.thanarie.dev`      | The platform team's testbed for platform changes. |
+| `gcp-pilot` | `*.canopy.monks.zone` | A pilot running on Google Cloud.                  |
+
+Sites are fully separate: a project on `main` doesn't exist on `staging`, and
+signing in to one doesn't create anything on another. They can also differ in
+what they support — the dashboard simply hides features a site can't honor,
+and the API says `not_supported_on_target` if asked directly.
+
+## What a profile is
+
+A **profile** is the CLI's name for a site. `canopy login` signs you in once
+via OneLogin and stores a credential for every site in one go; the profile
+just picks which one a command talks to.
+
+Three things decide the effective profile, in order:
+
+1. `--profile <id>` on the command (or the `CANOPY_PROFILE` environment
+   variable) — one-off override.
+2. The `"profile"` pinned in the project's `canopy.json` — set when the
+   project was created, so a checkout always targets the site it belongs to.
+3. Your default active profile — `main` unless you chose otherwise at login.
+
+Every command prints the site it's talking to in its header line, and
+`canopy whoami` shows your email, active profile, and API host — so there's
+never a mystery about where a deploy just went.
+
+```bash
+canopy whoami                          # who am I, on which site?
+canopy --profile gcp-pilot deploy      # one command against the pilot
+```
+
+## When you'd actually care
+
+- **Never, usually.** Day-to-day work on your own projects is all `main`,
+  and the `canopy.json` pin keeps it that way without any flags.
+- **Trying backend features.** Custom backends and
+  [schedules](https://docs.canopy.website/platform/schedules) currently run on `gcp-pilot`, so
+  experiments with those happen there.
+- **Helping test platform changes.** If the platform team asks you to check
+  something on `staging`, `--profile staging` points any command at it.
+
+> **Note:** Deploying to a different site publishes a **separate copy** of the project there — it doesn't move
+> or mirror the one on `main`. Each site keeps its own versions, data, and members.
+
+- [CLI reference](https://docs.canopy.website/guides/cli) — Every canopy command, including login, whoami, and the --profile flag.

package/dist/docs/static-serving.md

@@ -7,12 +7,10 @@ This explains the full path a browser request takes to receive a deployed
 project's `index.html` and its assets (JS/CSS/images/fonts), and reviews that
 path from a **security** and a **performance** angle.
 
-Everything a visitor sees is a _deployed_ build stored in R2. On Cloudflare
-there is no origin server running the project's code — the platform serves
-pre-built static files. (On the GCP target, `/api/*` requests dispatch to a
-per-project Cloud Run backend; everything else is still static serving. On
-Cloudflare, per-project workers remain a Phase 2 TODO and the capability is
-gated off.)
+Everything a visitor sees is a _deployed_ build stored in R2 — the platform
+serves pre-built static files. (When a project has a backend worker, `/api/*`
+requests dispatch to it — Workers for Platforms on Cloudflare, Cloud Run on
+GCP; everything else is still static serving.)
 
 Asset serving is the hottest **data-plane** path (see
 [`docs/09-plane-split.md`](../09-plane-split.md)): it lives at
@@ -213,8 +211,7 @@ These are observations, not known incidents — worth a conscious decision:
    runs on a `*.canopy.<domain>` origin that shares the session-cookie domain.
    The session cookie's flags (HttpOnly/SameSite/Secure) in
    [`session.ts`](../../apps/gateway/src/session.ts) are the mitigation to keep an
-   eye on; a per-project origin isolation (Phase 2 dev workers) would be the
-   stronger fix.
+   eye on; per-project origin isolation would be the stronger fix.
 3. **SPA fallback returns `index.html` with 200 for unknown paths**, including
    things that look like missing assets (`/assets/typo.js` → HTML). That's normal
    SPA behavior but can mask 404s and, combined with #1, is another reason

package/dist/docs/troubleshooting.md

@@ -47,11 +47,11 @@ The `CANOPY_DEPLOY_TOKEN` was revoked or is wrong. Create a new one with
 
 ## `not_supported_on_target` (501)
 
-Some features are platform-target-specific: on the Cloudflare target,
-per-project worker backends, dashboard schedules, and secret injection are not
-available and answer this error (the dashboard hides those panels). It's not a
-failure of your project — the feature doesn't exist on the target your platform
-runs on.
+Some features are platform-target-specific: a site whose platform target
+doesn't support a feature (for example per-project worker backends, dashboard
+schedules, or secret injection) answers this error, and the dashboard hides
+those panels. It's not a failure of your project — the feature doesn't exist
+on the target your platform runs on.
 
 ## `ai_budget_exceeded` (429)
 
@@ -73,9 +73,7 @@ canopy egress allow api.example.com
 
 or use dashboard Settings → Outbound hosts. Details and entry rules:
 [Outbound requests](https://docs.canopy.website/platform/egress). Calls made through the SDK /
-`env.CANOPY.fetch` don't count as egress and are unaffected. On the Cloudflare
-target outbound requests are currently unrestricted, so this error only
-appears on GCP.
+`env.CANOPY.fetch` don't count as egress and are unaffected.
 
 ## The worker returns errors and you can't see why
 

package/dist/{docs-DQmUReJR.mjs → docs-DOiL2Sw-.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-yVoO2pq4.mjs";
+import { t as version } from "./package-BNiOibhj.mjs";
 import { n as siteConfig } from "./site-BUlQR117.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
 import { n as reportErrors } from "./ui-CpdtK7mt.mjs";
@@ -9,9 +9,10 @@ import { join } from "node:path";
 import { fileURLToPath } from "node:url";
 //#region src/docs.ts
 /**
-* canopy docs — user/agent-facing guides, served live by the platform
-* (GET /control/v1/docs) so they never go stale, with a local cache and a bundled
-* snapshot as offline fallbacks.
+* canopy docs — the full docs site in the terminal (guides, platform, CLI and
+* SDK references), served live by the platform (GET /control/v1/docs) so it
+* never goes stale, with a local cache and a bundled snapshot as offline
+* fallbacks. The listing is grouped per docs-site section.
 *
 * The platform requires a login for docs (internal platform), so fetches carry
 * the CLI token when there is one; without it we simply fall back to the
@@ -98,15 +99,25 @@ function writeCache(file, content) {
 		writeFileSync(join(cacheDir, file), content);
 	} catch {}
 }
-/** Topics from cache, else from the bundled snapshot's frontmatter. */
-function topicsFromFallback() {
+/** The index from cache, else from the bundled snapshot. */
+function indexFromFallback() {
 	try {
 		const cached = JSON.parse(readFileSync(indexPath, "utf8"));
-		if (cached.topics?.length) return cached.topics;
+		if (cached.topics?.length) return {
+			topics: cached.topics,
+			sections: cached.sections
+		};
 	} catch {}
 	const dir = bundledDocsDir();
-	if (!dir) return [];
-	return readdirSync(dir).filter((f) => /\.mdx?$/.test(f)).map((f) => {
+	if (!dir) return { topics: [] };
+	try {
+		const { sections } = JSON.parse(readFileSync(join(dir, "index.json"), "utf8"));
+		if (sections?.length) return {
+			topics: sections.flatMap((s) => s.topics),
+			sections
+		};
+	} catch {}
+	return { topics: readdirSync(dir).filter((f) => /\.mdx?$/.test(f)).map((f) => {
 		const slug = f.replace(/\.mdx?$/, "");
 		const { title, summary } = parseFrontmatter(readFileSync(join(dir, f), "utf8"));
 		return {
@@ -114,7 +125,7 @@ function topicsFromFallback() {
 			title: title ?? slug,
 			summary: summary ?? ""
 		};
-	});
+	}) };
 }
 /** A single doc's body from cache, else from the bundled snapshot. */
 function bodyFromFallback(slug) {
@@ -129,7 +140,7 @@ function bodyFromFallback(slug) {
 		}
 	}
 }
-async function listTopics(refresh) {
+async function listIndex(refresh) {
 	const { apiUrl } = siteConfig();
 	if (refresh || !cacheFresh()) {
 		const data = await fetchJson(`${apiUrl}/control/v1/docs`);
@@ -138,10 +149,10 @@ async function listTopics(refresh) {
 				fetchedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				...data
 			}));
-			return data.topics;
+			return data;
 		}
 	}
-	return topicsFromFallback();
+	return indexFromFallback();
 }
 async function readTopic(slug, refresh) {
 	const { apiUrl } = siteConfig();
@@ -157,7 +168,7 @@ async function readTopic(slug, refresh) {
 const docsCommand = defineCommand({
 	meta: {
 		name: "docs",
-		description: "Read the Canopy guides (offline-capable)"
+		description: "Read the Canopy docs (offline-capable)"
 	},
 	args: {
 		topic: {
@@ -177,16 +188,27 @@ const docsCommand = defineCommand({
 		const latest = latestKnownVersion();
 		if (latest && compareSemver(version, latest) < 0) console.error(`Note: these docs describe CLI ${latest}; you have ${version} — commands or flags they mention may not exist here. Run \`canopy upgrade\`.\n`);
 		if (!topic) {
-			const topics = await listTopics(refresh);
-			if (topics.length === 0) throw new Error("No docs available — check your connection, or reinstall the CLI.");
-			const width = Math.max(...topics.map((t) => t.slug.length));
-			console.log("Canopy docs — run `canopy docs <topic>`:\n");
-			for (const t of topics) console.log(`  ${t.slug.padEnd(width)}  ${t.summary}`);
+			const index = await listIndex(refresh);
+			if (index.topics.length === 0) throw new Error("No docs available — check your connection, or reinstall the CLI.");
+			console.log("Canopy docs — run `canopy docs <topic>`:");
+			const groups = index.sections?.length ? index.sections : [{
+				key: "all",
+				title: "",
+				description: "",
+				topics: index.topics
+			}];
+			for (const section of groups) {
+				const heading = [section.title, section.description].filter(Boolean).join(" — ");
+				console.log(heading ? `\n${heading}` : "");
+				const width = Math.max(...section.topics.map((t) => t.slug.length));
+				for (const t of section.topics) console.log(`  ${t.slug.padEnd(width)}  ${t.summary}`);
+			}
 			return;
 		}
 		const body = await readTopic(topic, refresh);
 		if (body === void 0) {
-			const known = (await listTopics(false)).map((t) => t.slug).join(", ");
+			const { topics } = await listIndex(false);
+			const known = topics.map((t) => t.slug).join(", ");
 			throw new Error(`No doc "${topic}".${known ? ` Available: ${known}.` : ""}`);
 		}
 		console.log(body);

package/dist/feedback-BZG8E8zG.mjs

@@ -0,0 +1,258 @@
+import { t as version } from "./package-BNiOibhj.mjs";
+import { a as projectDirArgs, c as resolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-BUlQR117.mjs";
+import { c as apiRequest, n as reportErrors } from "./ui-CpdtK7mt.mjs";
+import { defineCommand } from "citty";
+//#region src/feedback.ts
+/**
+* canopy feedback — the ticket-lite feedback system (docs/19, docs topic
+* `platform-feedback`). Two jobs:
+*
+*  - Work a project's inbox: `list`, `show`, `comment`, `status` — the loop an
+*    agent runs over items a human marked `accepted`.
+*  - File reports: `report` sends a bug/feedback item. With no `--project` it
+*    lands on the **platform inbox** (canopy itself) — the right target when a
+*    canopy command misbehaves while you're building something else.
+*/
+const STATUSES = [
+	"new",
+	"accepted",
+	"in_progress",
+	"resolved",
+	"declined"
+];
+const KINDS = [
+	"bug",
+	"feedback",
+	"docs"
+];
+const jsonArg = { json: {
+	type: "boolean",
+	description: "Machine-readable JSON output"
+} };
+function firstLine(body) {
+	const line = body.split("\n")[0] ?? "";
+	return line.length > 72 ? `${line.slice(0, 71)}…` : line;
+}
+function printItems(items) {
+	if (items.length === 0) {
+		console.log("No matching feedback items.");
+		return;
+	}
+	for (const item of items) {
+		const comments = item.comment_count ? `  💬${item.comment_count}` : "";
+		console.log(`${item.id}  ${item.status}  ${item.kind}  ${firstLine(item.body)}${comments}`);
+	}
+}
+const feedbackCommand = defineCommand({
+	meta: {
+		name: "feedback",
+		description: "Work a project's feedback inbox, or file a report (see docs: platform-feedback)"
+	},
+	subCommands: {
+		list: defineCommand({
+			meta: {
+				name: "list",
+				description: "List the project's feedback inbox (members only)"
+			},
+			args: {
+				...projectDirArgs,
+				...jsonArg,
+				status: {
+					type: "string",
+					description: `Filter: ${STATUSES.join(" | ")}`
+				},
+				kind: {
+					type: "string",
+					description: `Filter: ${KINDS.join(" | ")}`
+				}
+			},
+			run: reportErrors("feedback list", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const params = new URLSearchParams();
+				if (args.status) params.set("status", args.status);
+				if (args.kind) params.set("kind", args.kind);
+				const { items } = await apiRequest("GET", `/projects/${slug}/feedback${params.size > 0 ? `?${params}` : ""}`);
+				if (args.json) console.log(JSON.stringify(items, null, 2));
+				else printItems(items);
+			})
+		}),
+		show: defineCommand({
+			meta: {
+				name: "show",
+				description: "Full detail of one item: body, context, comment trail"
+			},
+			args: {
+				id: {
+					type: "positional",
+					description: "Item id (from `canopy feedback list`)",
+					required: true
+				},
+				...projectDirArgs,
+				...jsonArg
+			},
+			run: reportErrors("feedback show", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const detail = await apiRequest("GET", `/projects/${slug}/feedback/${encodeURIComponent(args.id)}`);
+				if (args.json) {
+					console.log(JSON.stringify(detail, null, 2));
+					return;
+				}
+				const { item, comments } = detail;
+				console.log(`${item.kind} · ${item.status} · via ${item.source} · ${item.created_at}`);
+				console.log(`reported by ${item.reporter_name || item.reporter_email || "unknown"}` + (item.deployment_id ? ` on ${item.deployment_id}` : "") + (item.channel === "staging" ? " (staging)" : ""));
+				console.log(`\n${item.body}\n`);
+				if (item.context) {
+					console.log("context:");
+					try {
+						console.log(JSON.stringify(JSON.parse(item.context), null, 2));
+					} catch {
+						console.log(item.context);
+					}
+					console.log("");
+				}
+				for (const entry of comments) {
+					const author = entry.author_name || entry.author_email || "unknown";
+					const move = entry.status_to ? `  [${entry.status_from} → ${entry.status_to}]` : "";
+					console.log(`--- ${author} · ${entry.created_at}${move}`);
+					if (entry.body) console.log(entry.body);
+				}
+			})
+		}),
+		comment: defineCommand({
+			meta: {
+				name: "comment",
+				description: "Append a comment to an item (e.g. debug findings)"
+			},
+			args: {
+				id: {
+					type: "positional",
+					description: "Item id",
+					required: true
+				},
+				text: {
+					type: "positional",
+					description: "Comment text",
+					required: true
+				},
+				...projectDirArgs
+			},
+			run: reportErrors("feedback comment", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				await apiRequest("POST", `/projects/${slug}/feedback/${encodeURIComponent(args.id)}/comments`, { body: args.text });
+				console.log("Comment added.");
+			})
+		}),
+		status: defineCommand({
+			meta: {
+				name: "status",
+				description: "Move an item to a new status (members only)"
+			},
+			args: {
+				id: {
+					type: "positional",
+					description: "Item id",
+					required: true
+				},
+				to: {
+					type: "positional",
+					description: STATUSES.join(" | "),
+					required: true
+				},
+				comment: {
+					type: "string",
+					description: "Optional note recorded with the change"
+				},
+				...projectDirArgs
+			},
+			run: reportErrors("feedback status", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				await apiRequest("POST", `/projects/${slug}/feedback/${encodeURIComponent(args.id)}/status`, {
+					status: args.to,
+					...args.comment ? { comment: args.comment } : {}
+				});
+				console.log(`Marked ${args.id} as ${args.to}.`);
+			})
+		}),
+		mine: defineCommand({
+			meta: {
+				name: "mine",
+				description: "Your own reports across all projects"
+			},
+			args: {
+				...jsonArg,
+				project: {
+					type: "string",
+					description: "Only reports on this project slug"
+				}
+			},
+			run: reportErrors("feedback mine", async ({ args }) => {
+				const { items } = await apiRequest("GET", `/feedback/mine${args.project ? `?project=${encodeURIComponent(args.project)}` : ""}`);
+				if (args.json) {
+					console.log(JSON.stringify(items, null, 2));
+					return;
+				}
+				if (items.length === 0) {
+					console.log("You haven't filed any reports.");
+					return;
+				}
+				for (const item of items) console.log(`${item.id}  ${item.status}  ${item.kind}  [${item.project_slug}]  ${firstLine(item.body)}`);
+			})
+		}),
+		report: defineCommand({
+			meta: {
+				name: "report",
+				description: "File a report. Default target is the platform inbox (canopy itself); use --project for a specific project"
+			},
+			args: {
+				text: {
+					type: "positional",
+					description: "What happened / what you suggest",
+					required: true
+				},
+				kind: {
+					type: "string",
+					description: "bug | feedback (default: bug)"
+				},
+				project: {
+					type: "string",
+					description: "Project slug to file against (default: the platform inbox)"
+				},
+				command: {
+					type: "string",
+					description: "The canopy command that failed (goes in context)"
+				},
+				error: {
+					type: "string",
+					description: "The error output you saw (goes in context)"
+				}
+			},
+			run: reportErrors("feedback report", async ({ args }) => {
+				const kind = args.kind ?? "bug";
+				if (kind !== "bug" && kind !== "feedback") {
+					console.error(`--kind must be bug or feedback (got "${kind}")`);
+					process.exit(1);
+				}
+				const context = {
+					cli_version: version,
+					site: siteConfig().profileId ?? siteConfig().apiUrl,
+					platform: `${process.platform} node ${process.versions.node}`
+				};
+				const workingOn = tryReadCanopyJson(".")?.slug;
+				if (workingOn) context["working_on"] = workingOn;
+				if (args.command) context["command"] = args.command;
+				if (args.error) context["error"] = args.error;
+				const { item } = await apiRequest("POST", "/feedback", {
+					kind,
+					body: args.text,
+					source: "cli",
+					...args.project ? { project: args.project } : {},
+					context
+				});
+				console.log(`Filed ${kind} ${item.id} on ${item.project}.`);
+				console.log(`Follow it with \`canopy feedback mine\` or on the dashboard's Reports page.`);
+			})
+		})
+	}
+});
+//#endregion
+export { feedbackCommand };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-yVoO2pq4.mjs";
+import { t as version } from "./package-BNiOibhj.mjs";
 import { r as siteHeaderLine, t as setInvocationProfile } from "./site-BUlQR117.mjs";
 import { a as notifyOfUpdate, o as runRefresh } from "./version-check-CcsA1QjI.mjs";
 import { defineCommand, runMain } from "citty";
@@ -63,10 +63,10 @@ const main = defineCommand({
 		login: () => import("./login-C1x1l3qg.mjs").then((m) => m.loginCommand),
 		whoami: () => import("./login-C1x1l3qg.mjs").then((m) => m.whoamiCommand),
 		logout: () => import("./login-C1x1l3qg.mjs").then((m) => m.logoutCommand),
-		create: () => import("./projects-D2fDeWNU.mjs").then((m) => m.createCommand),
-		init: () => import("./projects-D2fDeWNU.mjs").then((m) => m.initCommand),
-		projects: () => import("./projects-D2fDeWNU.mjs").then((m) => m.projectsCommand),
-		delete: () => import("./projects-D2fDeWNU.mjs").then((m) => m.deleteCommand),
+		create: () => import("./projects-C9TBoiW7.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-C9TBoiW7.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-C9TBoiW7.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-C9TBoiW7.mjs").then((m) => m.deleteCommand),
 		dev: () => import("./dev-D6Sy15Wv.mjs").then((m) => m.devCommand),
 		deploy: () => import("./deploy-ClioT9ZC.mjs").then((m) => m.deployCommand),
 		promote: () => import("./deploy-ClioT9ZC.mjs").then((m) => m.promoteCommand),
@@ -75,13 +75,14 @@ const main = defineCommand({
 		download: () => import("./deploy-ClioT9ZC.mjs").then((m) => m.downloadCommand),
 		token: () => import("./token-BjlqT2Xj.mjs").then((m) => m.tokenCommand),
 		egress: () => import("./egress-BkkG9Jzs.mjs").then((m) => m.egressCommand),
+		feedback: () => import("./feedback-BZG8E8zG.mjs").then((m) => m.feedbackCommand),
 		db: () => import("./db-D3RKaLVU.mjs").then((m) => m.dbCommand),
 		usage: () => import("./usage-wpew0a2M.mjs").then((m) => m.usageCommand),
 		open: () => import("./open-CLSh6oez.mjs").then((m) => m.openCommand),
-		docs: () => import("./docs-DQmUReJR.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-12Ga-2UT.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-Du6U0xjp.mjs").then((m) => m.upgradeCommand),
-		logs: () => import("./logs-DBLDS3aQ.mjs").then((m) => m.logsCommand)
+		docs: () => import("./docs-DOiL2Sw-.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-DRTg-mJR.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-BDaM4M6Y.mjs").then((m) => m.upgradeCommand),
+		logs: () => import("./logs-DuzM-_Rn.mjs").then((m) => m.logsCommand)
 	}
 });
 if (process.argv[2] !== "upgrade") notifyOfUpdate(version);

package/dist/{logs-DBLDS3aQ.mjs → logs-DuzM-_Rn.mjs}

@@ -34,7 +34,7 @@ async function fetchLogs(slug, params) {
 	if (params.limit) query.set("limit", String(params.limit));
 	return withContext(apiRequest("GET", `/projects/${slug}/logs?${query}`), {
 		action: `read worker logs for "${slug}"`,
-		fixes: { not_supported_on_target: "Worker logs aren't available on this site yet — GCP sites only." }
+		fixes: { not_supported_on_target: "Worker logs aren't available on this site yet." }
 	});
 }
 const logsCommand = defineCommand({

package/dist/{package-yVoO2pq4.mjs → package-BNiOibhj.mjs}

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