@mediamonks/canopy-cli 0.7.7 → 0.7.9

package/dist/docs/platform-feedback.md

@@ -29,12 +29,41 @@ boards.
   "Bug" for "Docs issue", and `canopy-feedback-prompt` replaces the textarea
   placeholder. Kinds are limited to `bug`, `feedback`, `docs`.
 
+## Screenshots
+
+A screenshot is often the whole report, so you can attach up to six to any
+report:
+
+- **In the widget:** click **Attach screenshot**, or paste one straight from
+  the clipboard into the message box, or drop an image on the panel. Thumbnails
+  show what will be sent, and each one can be removed before you hit Send.
+- **On the dashboard:** the same three ways, from the report itself — so you can
+  add a picture to a report after filing it, or to a comment as you write it
+  ("here's what it looks like after the fix"). Click any thumbnail for the full
+  image, then use the arrow keys to page through the rest.
+- **From the CLI:** `canopy feedback report "…" --attach ./shot.png`, or
+  `canopy feedback attach <id> ./after-fix.png` for a report that already
+  exists. `canopy feedback show <id> --download <dir>` saves a report's
+  screenshots so an agent can look at them.
+
+PNG, JPEG, WebP and GIF, up to 5 MB each. Large screenshots are scaled down in
+your browser before they're sent, so a full-screen retina capture goes up small
+without you doing anything. Screenshots are visible to the same people as the
+report itself, and are deleted with it.
+
 ## 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."**
+- Statuses: `investigate → investigated → accepted → in_progress → resolved`,
+  plus `declined`.
+- Everything arrives as **investigate** — nobody has looked at it yet. An agent
+  can pick those up, work out what is actually going on, and write the findings
+  on the report as **investigated**.
+- **`accepted` means a person said "build this."** It is the one status an
+  agent should never reach for on its own.
+- The order is a suggestion, not a track. Accept something straight away, skip
+  the investigation, or decline it at any point.
 - 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
@@ -42,21 +71,27 @@ Project members triage reports on the **Feedback tab**:
 
 ## Working the backlog with an agent
 
-Because the CLI exposes the inbox, "work through the accepted feedback" is a
-prompt, not a process:
+Because the CLI exposes the inbox, "look into the new reports" and "work
+through the accepted feedback" are both prompts, not processes:
 
 ```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 list --status investigate      # what nobody has looked at yet
+canopy feedback show <id>                      # body + captured context + trail
+canopy feedback status <id> investigated \
+  --comment "root cause: the upload grant expires too early"
+canopy feedback list --status accepted         # what a person asked for
 canopy feedback status <id> resolved --comment "fixed in v42"
 ```
 
+`investigated` always carries the findings — the note is required, because a
+report that claims someone looked into it and shows nothing is worse than an
+untouched one. Then it waits: **accepting is the person's call**, so an agent
+sets `accepted` only when the person it is working with says to build the
+thing.
+
 `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.
+reported — reproduce against that, not whatever is live now. A report worth
+pushing back on gets `status <id> declined` with a comment saying why.
 
 ## Reporting problems with Canopy itself
 

package/dist/docs/platform-members-and-access.md

@@ -44,8 +44,8 @@ from the same card.
 
 Sometimes "any Monk can look" is too open — payroll prototypes, sensitive
 client work, unfinished things you'd rather not demo by accident. Flip on
-**Settings → Collaborators only** and the live app is limited to the
-project's roster:
+**Settings → Who at Monks can open it → Restrict to collaborators** and the
+live app is limited to the project's roster:
 
 - Other Monks who open the URL get a clear "limited to its collaborators"
   page instead of the app.

package/dist/docs/platform-project-data.md

@@ -8,17 +8,27 @@ created automatically the moment the project exists. There are no connection
 strings to configure and no servers to run — your app reads and writes through
 the Canopy SDK, and no other project can ever see your data.
 
-## The Data tab
+## The Data tab and the data explorer
 
 Open a project in the dashboard and the **Data** tab shows what your app has
-stored:
-
-- **Collections** — the document-style data your app writes with
-  `canopy.db.collection(...)`. Pick a collection and page through its rows.
-- **Tables** — a browser for the underlying database tables, for when your
-  app uses raw SQL or you want to see exactly what's on disk.
-- **SQL console** — run a query directly against the project's database from
-  the browser. Useful for quick checks and one-off fixes.
+stored — every collection and table at a glance — plus the door into the
+**data explorer**, a full-page workspace for actually digging in:
+
+- **Schema sidebar** — collections and tables, each expandable to its
+  columns (types, primary keys) and indexes.
+- **Browse** — click any table or collection to page through it with real
+  totals, sort by any column, and stack filters (equals, contains,
+  comparisons, null checks) without writing SQL. Click a row for the full
+  record, JSON pretty-printed. Export the current page as CSV or JSON.
+- **SQL console** — a real editor with syntax highlighting and autocomplete
+  fed by your schema. Run with <kbd>⌘⏎</kbd>, see row counts and timing,
+  recall earlier queries from history, and hit **Explain** to see the query
+  plan.
+
+The console is **read-only by default** — the platform rejects anything but
+reads until you flip the writes toggle, so exploring production data is safe
+by design. The explorer is fixed to the channel (live or staging) you opened
+it from; to look at the other one, go back to the Data tab and switch there.
 
 The **Files** tab next to it lists the project's blob storage — the uploads
 and files your app has saved.

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

@@ -1,7 +1,7 @@
-import { t as version } from "./package-BNiOibhj.mjs";
+import { t as version } from "./package-CGrKr6IT.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";
+import { n as reportErrors } from "./ui-2mrJcjYC.mjs";
 import { defineCommand } from "citty";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";

package/dist/{egress-BkkG9Jzs.mjs → egress-CN_axsAN.mjs}

@@ -1,5 +1,5 @@
 import { a as projectDirArgs, c as resolveProject } from "./site-BUlQR117.mjs";
-import { c as apiRequest, n as reportErrors } from "./ui-CpdtK7mt.mjs";
+import { c as apiRequest, n as reportErrors } from "./ui-2mrJcjYC.mjs";
 import { defineCommand } from "citty";
 //#region src/egress.ts
 /**

package/dist/feedback-DUuWXS_D.mjs

@@ -0,0 +1,390 @@
+import { t as version } from "./package-CGrKr6IT.mjs";
+import { a as projectDirArgs, c as resolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-BUlQR117.mjs";
+import { c as apiRequest, l as apiUpload, n as reportErrors, s as apiDownload } from "./ui-2mrJcjYC.mjs";
+import { defineCommand } from "citty";
+import { basename, extname, join } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+//#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` — investigate
+*    what came in (`investigate` → comment the findings → `investigated`), and
+*    build what 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 = [
+	"investigate",
+	"investigated",
+	"accepted",
+	"in_progress",
+	"resolved",
+	"declined"
+];
+const FILTER_STATUSES = [...STATUSES, "new"];
+const KINDS = [
+	"bug",
+	"feedback",
+	"docs"
+];
+/** Content-type hint from the extension; the server types the bytes itself. */
+const IMAGE_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".webp": "image/webp",
+	".gif": "image/gif"
+};
+/**
+* Every `--attach` on the command line. citty 0.2.2 has no array arg type and
+* keeps only the last occurrence, so repeats are read straight from argv;
+* `--attach a.png,b.png` works as well, since agents write it both ways.
+*/
+function attachedPaths(value) {
+	const flag = "--attach";
+	const repeated = process.argv.flatMap((arg, index) => {
+		if (arg === flag) {
+			const next = process.argv[index + 1];
+			return next && !next.startsWith("-") ? [next] : [];
+		}
+		return arg.startsWith(`${flag}=`) ? [arg.slice(9)] : [];
+	});
+	return (repeated.length > 0 ? repeated : value === void 0 ? [] : [String(value)]).flatMap((entry) => entry.split(",")).map((path) => path.trim()).filter((path) => path !== "");
+}
+/** Upload each file to a report that already exists (docs/21 create-then-attach). */
+async function attachFiles(slug, itemId, paths, caption, commentId) {
+	for (const [index, path] of paths.entries()) {
+		const bytes = await readFile(path);
+		const params = new URLSearchParams({ filename: basename(path) });
+		if (caption) params.set("caption", paths.length > 1 ? `${caption} (${index + 1})` : caption);
+		if (commentId) params.set("comment_id", commentId);
+		await apiUpload(`/projects/${slug}/feedback/${encodeURIComponent(itemId)}/attachments?${params}`, bytes, IMAGE_TYPES[extname(path).toLowerCase()] ?? "application/octet-stream");
+		console.log(`Attached ${basename(path)}.`);
+	}
+}
+function sizeLabel(bytes) {
+	return bytes >= 1024 * 1024 ? `${(bytes / (1024 * 1024)).toFixed(1)} MB` : `${Math.max(1, Math.round(bytes / 1024))} KB`;
+}
+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}` : "";
+		const shots = item.attachment_count ? `  📎${item.attachment_count}` : "";
+		console.log(`${item.id}  ${item.status}  ${item.kind}  ${firstLine(item.body)}${comments}${shots}`);
+	}
+}
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List the project's feedback inbox (members only)"
+	},
+	args: {
+		...projectDirArgs,
+		...jsonArg,
+		status: {
+			type: "string",
+			description: `Filter: ${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);
+	})
+});
+const showCommand = 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,
+		download: {
+			type: "string",
+			description: "Save the report's screenshots into this directory"
+		}
+	},
+	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("");
+		}
+		const shots = detail.attachments;
+		if (shots.length > 0) {
+			console.log("screenshots:");
+			for (const shot of shots) {
+				const label = shot.caption ? ` — ${shot.caption}` : "";
+				console.log(`  ${shot.id}  ${shot.filename ?? "screenshot"}  ${sizeLabel(shot.size_bytes)}${label}`);
+			}
+			if (!args.download) console.log("  (save them with --download <dir> to look at them)");
+			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);
+		}
+		if (args.download && shots.length > 0) {
+			console.log("");
+			for (const shot of shots) {
+				const bytes = await apiDownload(`/projects/${slug}/feedback/${encodeURIComponent(item.id)}/attachments/${shot.id}`);
+				const name = shot.filename ? `${shot.id}-${basename(shot.filename)}` : `${shot.id}.png`;
+				const target = join(args.download, name);
+				await writeFile(target, bytes);
+				console.log(`Saved ${target}`);
+			}
+		}
+	})
+});
+const commentCommand = 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.");
+	})
+});
+const statusCommand = 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: "Note recorded with the change (required for `investigated`)"
+		},
+		...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}.`);
+	})
+});
+const mineCommand = 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)}`);
+	})
+});
+const reportCommand = 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)"
+		},
+		attach: {
+			type: "string",
+			description: "Screenshot to attach (PNG/JPEG/WebP/GIF); repeat for several"
+		},
+		caption: {
+			type: "string",
+			description: "One line describing the screenshot(s)"
+		},
+		status: {
+			type: "string",
+			description: `Initial status, project members only: ${STATUSES.join(" | ")}`
+		}
+	},
+	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 paths = attachedPaths(args.attach);
+		for (const path of paths) await readFile(path);
+		const { item } = await apiRequest("POST", "/feedback", {
+			kind,
+			body: args.text,
+			...args.project ? { project: args.project } : {},
+			...args.status ? { status: args.status } : {},
+			context
+		});
+		console.log(`Filed ${kind} ${item.id} on ${item.project} as ${item.status}.`);
+		if (paths.length > 0) await attachFiles(item.project, item.id, paths, args.caption);
+		console.log(`Follow it with \`canopy feedback mine\` or on the dashboard's Reports page.`);
+	})
+});
+const feedbackCommand = defineCommand({
+	meta: {
+		name: "feedback",
+		description: "Work a project's feedback inbox, or file a report (see docs: platform-feedback)"
+	},
+	subCommands: {
+		list: listCommand,
+		show: showCommand,
+		comment: commentCommand,
+		attach: defineCommand({
+			meta: {
+				name: "attach",
+				description: "Attach screenshots to an existing item (e.g. proof that a fix works)"
+			},
+			args: {
+				id: {
+					type: "positional",
+					description: "Item id",
+					required: true
+				},
+				file: {
+					type: "positional",
+					description: "Image file (repeat --attach for more)",
+					required: true
+				},
+				attach: {
+					type: "string",
+					description: "Another image file; repeat for several"
+				},
+				caption: {
+					type: "string",
+					description: "One line describing the screenshot(s)"
+				},
+				comment: {
+					type: "string",
+					description: "Post this comment first and hang the screenshots off it"
+				},
+				...projectDirArgs
+			},
+			run: reportErrors("feedback attach", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const paths = [args.file, ...attachedPaths(args.attach)];
+				for (const path of paths) await readFile(path);
+				let commentId;
+				if (args.comment) {
+					const { comment } = await apiRequest("POST", `/projects/${slug}/feedback/${encodeURIComponent(args.id)}/comments`, { body: args.comment });
+					commentId = comment.id;
+					console.log("Comment added.");
+				}
+				await attachFiles(slug, args.id, paths, args.caption, commentId);
+			})
+		}),
+		status: statusCommand,
+		mine: mineCommand,
+		report: reportCommand
+	}
+});
+//#endregion
+export { feedbackCommand };

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-BNiOibhj.mjs";
+import { t as version } from "./package-CGrKr6IT.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";
@@ -60,29 +60,29 @@ const main = defineCommand({
 		description: "canopy — create and deploy vibecoded projects"
 	},
 	subCommands: {
-		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-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),
-		staging: () => import("./staging-95xeXyZN.mjs").then((m) => m.stagingCommand),
-		rollback: () => import("./deploy-ClioT9ZC.mjs").then((m) => m.rollbackCommand),
-		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-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)
+		login: () => import("./login-D7dI8D9N.mjs").then((m) => m.loginCommand),
+		whoami: () => import("./login-D7dI8D9N.mjs").then((m) => m.whoamiCommand),
+		logout: () => import("./login-D7dI8D9N.mjs").then((m) => m.logoutCommand),
+		create: () => import("./projects-C6JQjVqg.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-C6JQjVqg.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-C6JQjVqg.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-C6JQjVqg.mjs").then((m) => m.deleteCommand),
+		dev: () => import("./dev-BYxSHUH6.mjs").then((m) => m.devCommand),
+		deploy: () => import("./deploy-y75cgauK.mjs").then((m) => m.deployCommand),
+		promote: () => import("./deploy-y75cgauK.mjs").then((m) => m.promoteCommand),
+		staging: () => import("./staging-Bw1D_J8M.mjs").then((m) => m.stagingCommand),
+		rollback: () => import("./deploy-y75cgauK.mjs").then((m) => m.rollbackCommand),
+		download: () => import("./deploy-y75cgauK.mjs").then((m) => m.downloadCommand),
+		token: () => import("./token-D7zrIF8G.mjs").then((m) => m.tokenCommand),
+		egress: () => import("./egress-CN_axsAN.mjs").then((m) => m.egressCommand),
+		feedback: () => import("./feedback-DUuWXS_D.mjs").then((m) => m.feedbackCommand),
+		db: () => import("./db-8Etjmzxh.mjs").then((m) => m.dbCommand),
+		usage: () => import("./usage-CX1Izj_l.mjs").then((m) => m.usageCommand),
+		open: () => import("./open-DRPp4QJg.mjs").then((m) => m.openCommand),
+		docs: () => import("./docs-VmcoH1An.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-CZP1AqQX.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-CmhSO_r6.mjs").then((m) => m.upgradeCommand),
+		logs: () => import("./logs-DNiZquki.mjs").then((m) => m.logsCommand)
 	}
 });
 if (process.argv[2] !== "upgrade") notifyOfUpdate(version);