@mediamonks/canopy-cli 0.7.6 → 0.7.7

package/dist/docs/cli-feedback.md

@@ -0,0 +1,51 @@
+---
+title: canopy feedback
+description: Read and triage a project's feedback inbox, or file a bug/feedback report — against a project or against Canopy itself.
+---
+
+`canopy feedback` is the CLI side of [Feedback & bug reports](https://docs.canopy.website/platform/feedback):
+agents (and humans) pull reports, append findings, move statuses, and file new
+ones.
+
+## Usage
+
+```bash
+canopy feedback list --status accepted
+canopy feedback show <id>
+canopy feedback comment <id> "root cause: the upload grant expires too early"
+canopy feedback status <id> resolved --comment "fixed in v42"
+canopy feedback mine
+canopy feedback report "canopy deploy exits 1 after upload" --command "canopy deploy"
+```
+
+## Subcommands
+
+Inbox commands (`list`, `show`, `comment`, `status`) resolve the project the
+usual way — `canopy.json` in the target directory, or `--project <slug>` — and
+require project membership. `list` and `show` take `--json` for
+machine-readable output.
+
+- `list [--status <s>] [--kind <k>]` — the project's inbox. Statuses:
+  `new`, `accepted`, `in_progress`, `resolved`, `declined`; kinds: `bug`,
+  `feedback`, `docs`.
+- `show <id>` — full detail: body, captured context (page URL, deploy
+  version, console errors — or CLI context), and the comment trail.
+- `comment <id> <text>` — append a comment (findings, questions, updates).
+- `status <id> <new-status> [--comment <note>]` — move the ticket; the
+  transition is recorded on the trail.
+- `mine [--project <slug>] [--json]` — your own reports across all projects,
+  with current statuses.
+- `report <text> [--kind bug|feedback] [--project <slug>] [--command <cmd>] [--error <output>]` —
+  file a new report. **Without `--project` it goes to the platform inbox**
+  (Canopy itself) — the right target when a `canopy` command misbehaves. The
+  CLI attaches its version, the active site, your platform, and the project
+  you were working in.
+
+## For agents
+
+The intended loop: a human marks items `accepted` on the dashboard; the agent
+runs `list --status accepted`, reproduces using the context in `show`
+(including the deploy version that served the page), comments findings, and
+resolves — or declines with a comment saying why. When a `canopy` command
+itself fails: rule out user error, check `canopy feedback mine` for a
+duplicate, then `report` with the exact command and error output.

package/dist/docs/index.json

@@ -129,6 +129,11 @@
           "title": "Members & access",
           "summary": "Everything on Canopy sits behind Monks sign-in. Collaborators manage a project; other Monks can view the live app — unless you tighten it."
         },
+        {
+          "slug": "platform-feedback",
+          "title": "Feedback & bug reports",
+          "summary": "A built-in feedback widget on every project, a ticket-lite inbox behind it, and a CLI that lets agents work the backlog."
+        },
         {
           "slug": "platform-client-access",
           "title": "Client access",
@@ -241,6 +246,11 @@
           "title": "canopy usage",
           "summary": "Show a project's AI spend, storage footprint, and deploy count from the terminal."
         },
+        {
+          "slug": "cli-feedback",
+          "title": "canopy feedback",
+          "summary": "Read and triage a project's feedback inbox, or file a bug/feedback report — against a project or against Canopy itself."
+        },
         {
           "slug": "cli-open",
           "title": "canopy open",

package/dist/docs/platform-feedback.md

@@ -0,0 +1,79 @@
+---
+title: Feedback & bug reports
+description: A built-in feedback widget on every project, a ticket-lite inbox behind it, and a CLI that lets agents work the backlog.
+---
+
+Every Canopy project gets an in-app feedback channel without writing a line of
+code: signed-in Monks see a small floating button on the live app, pick **Bug**
+or **Feedback**, type what happened, and send. The report lands in the
+project's **Feedback tab** on the dashboard, with everything an investigator
+needs captured automatically — page URL, the deploy version that served it,
+viewport, and recent console errors.
+
+It is deliberately **not** a ticketing product: an item has a status, an
+append-only comment trail, and nothing else. No assignees, priorities, or
+boards.
+
+## The widget
+
+- Appears only for **signed-in Monks**. Client-password visitors never see it —
+  the platform doesn't even send them the script.
+- On by default for every project. Turn it off per project in
+  **Settings → Feedback widget**; the change applies on the next page load.
+- Submissions are always identified (your company sign-in), so there's no
+  anonymous spam and no reporter field to fill in.
+- The widget also shows your own previous reports for that project with their
+  current status.
+- A page can reshape the chooser with meta tags — this docs site does exactly
+  that: `<meta name="canopy-feedback-kinds" content="docs,feedback">` swaps
+  "Bug" for "Docs issue", and `canopy-feedback-prompt` replaces the textarea
+  placeholder. Kinds are limited to `bug`, `feedback`, `docs`.
+
+## The inbox
+
+Project members triage reports on the **Feedback tab**:
+
+- Statuses: `new → accepted → in_progress → resolved`, plus `declined`.
+  **`accepted` means "this is valid — an agent may pick it up."**
+- Every status change and comment is recorded on the item's trail.
+- Reporters follow their submissions on the **Reports page** (dashboard
+  header) and can comment on or withdraw their own items; only project
+  members change statuses.
+
+## Working the backlog with an agent
+
+Because the CLI exposes the inbox, "work through the accepted feedback" is a
+prompt, not a process:
+
+```bash
+canopy feedback list --status accepted        # what a human marked valid
+canopy feedback show <id>                     # body + captured context + trail
+canopy feedback comment <id> "root cause: …"  # append findings
+canopy feedback status <id> resolved --comment "fixed in v42"
+```
+
+`show` includes the deploy version that served the page when the bug was
+reported — reproduce against that, not whatever is live now. An agent that
+investigates but can't fix should `comment` its findings and leave the status
+for a human; one that pushes back should `status <id> declined` with a comment
+saying why.
+
+## Reporting problems with Canopy itself
+
+When a `canopy` command fails while you (or your agent) are building a
+project, file it against the **platform inbox** — not your own project:
+
+```bash
+canopy feedback report "deploy failed after upload" \
+  --command "canopy deploy --staging" --error "upload_grant_expired …"
+```
+
+With no `--project`, the report goes to the platform team automatically, with
+your CLI version, site, and the project you were working on attached. Before
+filing: rule out user error first (`canopy docs troubleshooting`,
+`vp env doctor` for toolchain issues), and skim `canopy feedback mine` to
+avoid filing the same issue twice.
+
+## CLI reference
+
+See [canopy feedback](https://docs.canopy.website/cli/feedback) for every subcommand and flag.

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

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

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-CPXtNnfc.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";
@@ -75,12 +75,13 @@ 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-DhAz6QWS.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-BCX4cUeP.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-jLu7jI0r.mjs").then((m) => m.upgradeCommand),
+		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)
 	}
 });

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

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

package/dist/skill/canopy/SKILL.md

@@ -96,6 +96,8 @@ and never go stale.
 - Roll back: `canopy rollback`
 - Open the live site: `canopy open`
 - Manage data: `canopy db pull | snapshot | snapshots | restore | migrate`
+- Work bug reports & feedback: `canopy feedback list | show | comment | status | report`
+  — see `canopy docs platform-feedback` for the triage and reporting loops
 - CI credentials: `canopy token create | list | revoke`
 
 ## Custom tables & migrations (devs; Drizzle recommended)
@@ -151,3 +153,8 @@ Non-interactive: `canopy create "My App" --template spa`. **When unsure between
 - **Deploys are public.** `canopy deploy` makes a version live. Confirm before
   deploying unless the user clearly asked you to.
 - Keep the CLI current: `canopy upgrade` (this also refreshes this skill).
+- **A `canopy` command itself failing?** First rule out user error (re-read
+  `canopy docs troubleshooting` and the command's `--help`). If the platform
+  really misbehaved, check `canopy feedback mine` for a duplicate, then file it:
+  `canopy feedback report "<what happened>" --command "<the command>" --error "<output>"`
+  — it reaches the platform team directly (no `--project` needed).

package/dist/{skill-BCX4cUeP.mjs → skill-DRTg-mJR.mjs}

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

package/dist/{upgrade-jLu7jI0r.mjs → upgrade-BDaM4M6Y.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-BCX4cUeP.mjs");
+		const { skillInstalled } = await import("./skill-DRTg-mJR.mjs");
 		const refreshSkill = skillInstalled(process.cwd());
 		console.log(`Upgrading via ${command}: ${command} ${cmd.join(" ")}`);
 		await run(command, cmd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediamonks/canopy-cli",
-  "version": "0.7.6",
+  "version": "0.7.7",
   "description": "Canopy CLI — create, develop and deploy Canopy projects.",
   "bin": {
     "canopy": "./dist/index.mjs"
@@ -20,8 +20,8 @@
     "esbuild": "^0.28.1",
     "hono": "^4.8.0",
     "vite-server": "npm:vite@^7",
-    "@mediamonks/canopy-data-plane": "0.0.2",
-    "@mediamonks/canopy": "0.0.4"
+    "@mediamonks/canopy": "0.0.4",
+    "@mediamonks/canopy-data-plane": "0.0.2"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",