@mediamonks/canopy-cli 0.7.11 → 0.7.13

package/dist/{db-8Etjmzxh.mjs → db-DKnJQPm5.mjs}

@@ -1,6 +1,6 @@
 import { c as resolveProject, o as projectFlagArgs } from "./site-BUlQR117.mjs";
-import { i as unwrap, n as reportErrors, o as apiDataRequest, r as requireTty, u as withContext } from "./ui-2mrJcjYC.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C-5x6SYf.mjs";
+import { i as unwrap, n as reportErrors, o as apiDataRequest, r as requireTty, u as withContext } from "./ui-B1Px5y7q.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C6EcKD6a.mjs";
 import { defineCommand } from "citty";
 import { readFileSync, writeFileSync } from "node:fs";
 import * as p from "@clack/prompts";

package/dist/{deploy-BCtEY1is.mjs → deploy-CnxJ4TE6.mjs}

@@ -1,6 +1,6 @@
 import { a as projectDirArgs, c as resolveProject, l as stagingUrl, n as siteConfig, o as projectFlagArgs, s as projectUrl, u as tryReadCanopyJson } from "./site-BUlQR117.mjs";
-import { c as apiRequest, i as unwrap, n as reportErrors, o as apiDataRequest, s as apiDownload, u as withContext } from "./ui-2mrJcjYC.mjs";
-import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C-5x6SYf.mjs";
+import { c as apiRequest, i as unwrap, n as reportErrors, o as apiDataRequest, s as apiDownload, u as withContext } from "./ui-B1Px5y7q.mjs";
+import { n as migrateProject, r as readMigrationFiles, t as describeMigrateResult } from "./migrations-C6EcKD6a.mjs";
 import { defineCommand } from "citty";
 import { mkdtempSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
@@ -113,6 +113,12 @@ const deployCommand = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Deploy to the project's staging channel (created on first use, database cloned from live)"
+		},
+		worker: {
+			type: "boolean",
+			default: true,
+			description: "Include the backend worker from canopy.json",
+			negativeDescription: "Deploy the frontend only — for sites whose target hosts no per-project backends"
 		}
 	},
 	run: reportErrors("deploy", async ({ args }) => {
@@ -145,7 +151,8 @@ const deployCommand = defineCommand({
 			});
 		}
 		let workerBytes = null;
-		if (config.worker) {
+		if (config.worker && !args.worker) p.log.warn(`Skipping the backend (${config.worker}) — deploying the frontend only.`);
+		if (config.worker && args.worker) {
 			const spinWorker = p.spinner();
 			spinWorker.start(`Bundling worker ${config.worker}`);
 			try {

package/dist/dev-BqLvttKc.mjs

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

package/dist/{dev-DtoZrexp.mjs → dev-CyJT6EfQ.mjs}

@@ -1,6 +1,6 @@
 import { a as projectDirArgs, c as resolveProject, i as projectDialect, n as siteConfig, u as tryReadCanopyJson } from "./site-BUlQR117.mjs";
-import { a as ApiError, c as apiRequest, n as reportErrors, u as withContext } from "./ui-2mrJcjYC.mjs";
-import { r as readMigrationFiles } from "./migrations-C-5x6SYf.mjs";
+import { a as ApiError, c as apiRequest, n as reportErrors, u as withContext } from "./ui-B1Px5y7q.mjs";
+import { r as readMigrationFiles } from "./migrations-C6EcKD6a.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
@@ -37,7 +37,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-BZgtEM9V.mjs");
+	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-IWnHvQ1f.mjs");
 	const secrets = readDevVars(flags.dir);
 	const email = siteConfig().email;
 	const plugin = workerDevPlugin({
@@ -165,7 +165,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-C5AhA4GM.mjs");
+		const { fetchProjectDump } = await import("./local-BQxsp-ZQ.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -180,7 +180,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-C5AhA4GM.mjs");
+	const { createSandbox } = await import("./local-BQxsp-ZQ.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),
@@ -233,7 +233,8 @@ async function devLocal(flags, slug) {
 	const server = await startVite(flags, { proxy: {
 		...remoteEntry && {
 			"/_api/data/v1/ai": remoteEntry,
-			"/_api/data/v1/services": remoteEntry
+			"/_api/data/v1/services": remoteEntry,
+			"/_api/data/v1/google": remoteEntry
 		},
 		"/_api": {
 			target: `http://127.0.0.1:${apiAddress.port}`,

package/dist/{dev-worker-BZgtEM9V.mjs → dev-worker-IWnHvQ1f.mjs}

@@ -1,5 +1,43 @@
+import "./src-Bu4Ze32I.mjs";
 import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
+//#region ../data-plane/src/worker-request.ts
+/**
+* How a project's backend addresses the platform — the one definition.
+*
+* Three hosts run project workers and each builds this request itself: the
+* Workers-for-Platforms shim (apps/api/src/platform/wfp-shim.ts), the Node
+* runtime (apps/project-runtime/src/canopy-fetch.ts), and `canopy dev`
+* (packages/cli/src/dev-worker.ts). They had three copies of the header
+* shaping, and the two that hold a worker token had two copies of the
+* credential rule — which is exactly how the Google project grant came to
+* work on one target and not the other.
+*
+* The shim cannot import this: it ships as a standalone module uploaded
+* beside the user bundle, so it may only import `./bundle.mjs`. It keeps a
+* transcription, and `wfp-shim.test.ts` runs it against the table in
+* `worker-request.cases.ts` alongside this implementation, so the two cannot
+* drift silently.
+*/
+/** Gateway-stamped identity, for the worker's own `env.USER` — never relayed. */
+const IDENTITY_STAMP_HEADERS = [
+	"x-canopy-user-sub",
+	"x-canopy-user-email",
+	"x-canopy-user-name"
+];
+/**
+* Strip what must never travel upstream and stamp who is calling. Common to
+* every host; says nothing about credentials.
+*/
+function stampWorkerHeaders(headers, ctx) {
+	headers.delete("host");
+	for (const stamp of IDENTITY_STAMP_HEADERS) headers.delete(stamp);
+	headers.set("x-canopy-project", ctx.projectSlug);
+	if (ctx.channel === "staging") headers.set("x-canopy-channel", "staging");
+	else headers.delete("x-canopy-channel");
+	return headers;
+}
+//#endregion
 //#region src/dev-worker.ts
 /**
 * Paths that belong to the worker rather than the SPA — the gateway's rule
@@ -79,15 +117,12 @@ function rewriteCanopyUrl(raw, base) {
 function createCanopyFetch(apiBase, slug, channel, fetchImpl = fetch) {
 	return async (input, init) => {
 		const url = rewriteCanopyUrl(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, apiBase());
-		const headers = new Headers(input instanceof Request ? input.headers : init?.headers);
-		headers.delete("host");
-		headers.delete("x-canopy-user-sub");
-		headers.delete("x-canopy-user-email");
-		headers.delete("x-canopy-user-name");
+		const headers = stampWorkerHeaders(new Headers(input instanceof Request ? input.headers : init?.headers), {
+			projectSlug: slug,
+			channel
+		});
 		headers.delete("authorization");
 		headers.delete("cookie");
-		headers.set("x-canopy-project", slug);
-		if (channel === "staging") headers.set("x-canopy-channel", "staging");
 		const method = (input instanceof Request ? input.method : init?.method) ?? "GET";
 		const body = input instanceof Request ? input.body : init?.body;
 		const outbound = {

package/dist/docs/index.json

@@ -124,6 +124,11 @@
           "title": "AI access & usage",
           "summary": "Projects talk to AI models through the platform — no API keys to manage, a hard daily budget per project, and full visibility of spend."
         },
+        {
+          "slug": "platform-google",
+          "title": "Google",
+          "summary": "Let your project work with Google data — Sheets, Docs, Calendar, Drive, Gmail — without handling any OAuth yourself."
+        },
         {
           "slug": "platform-members-and-access",
           "title": "Members & access",

package/dist/docs/platform-google.md

@@ -0,0 +1,213 @@
+---
+title: Google
+description: Let your project work with Google data — Sheets, Docs, Calendar, Drive, Gmail — without handling any OAuth yourself.
+---
+
+Your project can work with Google data in two different ways, and the
+difference matters: as **the project's own account**, or as **each visitor's
+own account**.
+
+Either way there is no OAuth setup to do. No Cloud project, no consent screen,
+no client ID or secret, no redirect URLs, no tokens to store or refresh. Canopy
+holds all of that.
+
+## The project's own account
+
+The owner connects one Google account on the project's **Services** tab and
+picks what it may do. Everything the project sends to Google then happens as
+that account — including scheduled jobs that run when nobody is signed in. A
+shared team account is usually a better choice than a personal one.
+
+This account is **only usable from your backend code**:
+
+```ts
+// in your worker
+const doc = await canopy.google.project().fetch("https://docs.googleapis.com/v1/documents/<id>");
+```
+
+Pages cannot use it at all. That is deliberate: it is one person's real
+account, and anything a page can call, any visitor can call from their browser
+console. When your pages need something from it, put a route in your backend
+that returns just that — you decide what to expose.
+
+> **Note:** Only the project owner can connect or disconnect this account.
+
+## Each visitor's own account
+
+Visitors can connect their own Google account to your project, and your pages
+can then work with _their_ data — their calendar, their documents. They consent
+themselves, and it only ever acts as them.
+
+First, on the **Services** tab, tick what your app is allowed to ask visitors
+for. Your app can never request more than that.
+
+Then, from your pages:
+
+```ts
+const google = canopy.google.user();
+
+// On load: has this visitor connected, and what came back from a connect?
+const result = google.consumeConnectResult(); // toast this, if not null
+const status = await google.status();
+
+if (!status.connected) {
+  // A full-page trip to Google, then straight back to this page.
+  google.connect(["calendar"]);
+}
+
+const events = await google.fetch(
+  "https://www.googleapis.com/calendar/v3/calendars/primary/events",
+);
+```
+
+`connect()` leaves the page, so put the button somewhere without unsaved work.
+When the visitor comes back, `status()` is the reliable answer to "are they
+connected" — `consumeConnectResult()` just tells you how the trip that _just_
+happened went, so you can show a message.
+
+Google asks the visitor for exactly the permissions you passed. Nothing your
+project holds elsewhere carries over into what they see.
+
+Your backend can use a visitor's connection too, while handling that visitor's
+request — same `canopy.google.user()`, same account. It cannot in a scheduled
+job, because then nobody is signed in.
+
+> **Note:** Visitors need a Monks account to connect. People visiting with a project password cannot connect
+> their own Google account.
+
+## What a connection can reach
+
+Permissions are grouped by product — Sheets, Docs, Slides, Calendar, Drive,
+Gmail, Directory, Tasks, Forms, Meet — and most come in a reading and a
+read-and-write form. Pick the narrowest that does the job: a page that shows a
+spreadsheet wants **read spreadsheets**, not read and write.
+
+A few are narrower than they first look, and are usually the right answer —
+the full list is below:
+
+| Instead of               | Consider                                                                                   |
+| ------------------------ | ------------------------------------------------------------------------------------------ |
+| Read and write events    | **Availability only** — find free slots without seeing what any meeting is                 |
+| Read and write events    | **Its own calendar** — a separate calendar your project owns, never touching the account's |
+| Files this project makes | **Its own config folder** — a hidden folder nothing else can see                           |
+
+A call to anything that wasn't ticked is refused before it reaches Google, and
+so is a write using a reading-only permission.
+
+Drive is deliberately limited to files your project created or that someone
+explicitly opened with it — connecting Drive does not expose a whole Drive.
+
+### Wider permissions
+
+A few permissions read broadly across an account — a whole mailbox, meeting
+recordings. Those are switched off until a Canopy admin unlocks them for your
+project, and the picker shows them greyed out with the reason. Ask if you need
+one. Others are listed as _under consideration_: they exist, we haven't opened
+them yet.
+
+## Every permission
+
+Grouped the way the picker groups them. Pick the narrowest row that does
+the job — most products offer a reading-only version, and a write using a
+reading-only permission is refused before it reaches Google.
+
+**Sheets**
+
+| Permission                  | What it allows                                              |
+| --------------------------- | ----------------------------------------------------------- |
+| Read spreadsheets           | Read spreadsheets the account can open. Cannot change them. |
+| Read and write spreadsheets | Read and change spreadsheets the account can open.          |
+
+**Docs**
+
+| Permission               | What it allows                                           |
+| ------------------------ | -------------------------------------------------------- |
+| Read documents           | Read documents the account can open. Cannot change them. |
+| Read and write documents | Read and change documents the account can open.          |
+
+**Slides**
+
+| Permission                   | What it allows                                               |
+| ---------------------------- | ------------------------------------------------------------ |
+| Read presentations           | Read presentations the account can open. Cannot change them. |
+| Read and write presentations | Build and change presentations the account can open.         |
+
+**Calendar**
+
+| Permission                                   | What it allows                                                                      |
+| -------------------------------------------- | ----------------------------------------------------------------------------------- |
+| Availability only                            | See when the account is free or busy, never what the meetings are.                  |
+| Read events                                  | Read events on the account's calendars. Cannot change them.                         |
+| Read and write events                        | Read and manage events on the account's calendars.                                  |
+| Its own calendar                             | A separate calendar this project creates and owns. Never touches the account's own. |
+| Manage all calendars _(under consideration)_ | Full control of every calendar, including creating and deleting them.               |
+
+**Drive**
+
+| Permission                                    | What it allows                                                                |
+| --------------------------------------------- | ----------------------------------------------------------------------------- |
+| Files this project makes                      | Create files, and reopen the ones this project made or someone picked for it. |
+| Its own config folder                         | A hidden folder only this project can see. Invisible in the account's Drive.  |
+| Recordings and transcripts **(wider access)** | Read the recordings and transcripts Meet saved to Drive.                      |
+| Read the whole Drive _(under consideration)_  | Read and download every file the account can see.                             |
+| Read all file names _(under consideration)_   | Names and metadata of every file the account can see, without contents.       |
+| Full Drive access _(under consideration)_     | Read, change and delete every file the account can see.                       |
+
+**Gmail**
+
+| Permission                                     | What it allows                                                   |
+| ---------------------------------------------- | ---------------------------------------------------------------- |
+| Send mail                                      | Send mail as the account. Cannot read the mailbox.               |
+| Read mail **(wider access)**                   | Read the account's mail. Cannot send, change or delete anything. |
+| Read and organise mail _(under consideration)_ | Read, label and archive mail. Cannot permanently delete.         |
+
+**Directory**
+
+| Permission                                        | What it allows                                                       |
+| ------------------------------------------------- | -------------------------------------------------------------------- |
+| Look people up                                    | Search the organisation's directory for colleagues.                  |
+| Read personal contacts                            | Read the account's own contacts.                                     |
+| Read org users and groups _(under consideration)_ | Admin view of every user and group. Only works for Workspace admins. |
+
+**Tasks**
+
+| Permission           | What it allows                     |
+| -------------------- | ---------------------------------- |
+| Read tasks           | Read the account's task lists.     |
+| Read and write tasks | Create, change and complete tasks. |
+
+**Forms**
+
+| Permission          | What it allows                                           |
+| ------------------- | -------------------------------------------------------- |
+| Read form structure | Read a form's questions and settings, not its responses. |
+| Build forms         | Create and change forms.                                 |
+| Read responses      | Read what people submitted. Often personal information.  |
+
+**Meet**
+
+| Permission                  | What it allows                                             |
+| --------------------------- | ---------------------------------------------------------- |
+| Meetings this project makes | Create meeting links and read details of the ones it made. |
+
+## When a connection stops working
+
+Google grants end on their own sometimes: someone changes their password,
+removes Canopy from their account permissions, or the connection sits unused
+for six months. Calls then fail asking for a reconnect. For the project's
+account, the owner reconnects on the Services tab; for a visitor's, show the
+connect button again. Nothing else needs changing.
+
+Disconnecting also tells Google the grant is over, so access stops immediately
+rather than lingering. Visitors can drop their own connection with
+`canopy.google.user().disconnect()`.
+
+## Local development
+
+`canopy dev` uses the real connections, so Google works the same on your
+machine as in production — including with `--local`. There is nothing to set up
+locally, and no localhost URLs to register.
+
+Because it is real, calls in development touch real data. Sending mail really
+sends it. If that matters, connect a test account on your project's staging
+channel and develop against that.

package/dist/docs/static-serving.md

@@ -34,7 +34,7 @@ canopy-gateway  (apps/gateway/src/index.ts)
   ▼  env.API.fetch(...)  (service binding, no public hop)
 canopy-api  (apps/api/src/routes/assets.ts)
   │  4. Resolve the project from the stamp + which version is live
-  │  5. Sanitize the asset path, SPA-fallback to index.html
+  │  5. Sanitize the asset path; directory index, else SPA fallback
   │  6. R2 GET  deploys/<project-id>/<version>/<path>
   ▼
 R2 bucket "canopy-assets"
@@ -102,14 +102,19 @@ The serving handler is `GET /data/v1/assets/*` in
   project's deploy history, else 404 — it never silently falls back to live);
   otherwise the snapshot's `liveAssetVersion` is served, which falls back to
   the max deployed version for legacy rows with a NULL pointer.
-- **Path → R2 key.** The tail after `/assets/` is sanitized (see Security),
-  defaulting to `index.html`, and mapped to the R2 key
-  `deploys/<project-id>/<version>/<path>`.
-- **SPA fallback + read**: the exact asset is read first, and any miss falls
-  back to `index.html`, so client-side routes (`/settings`, `/projects/42`) all
-  resolve to the SPA entry point. The fallback `index.html` is served from a
-  per-version cache (see [Performance](#performance-review)), so a deep-linked
-  route doesn't pay a second R2 read on every request.
+- **Path → R2 key.** The tail after `/assets/` is sanitized (see Security)
+  and mapped to the R2 key `deploys/<project-id>/<version>/<path>`; the root
+  path serves `index.html`.
+- **Directory index + SPA fallback**: the exact asset is read first. On a
+  miss, an extensionless path is probed for its own directory index — `/feeds/`
+  serves `feeds/index.html` (multi-page static exports), and the slash-less
+  `/feeds` 301-redirects to `/feeds/` so the page's relative URLs resolve.
+  Only when no directory index exists does the request fall back to the root
+  `index.html`, so client-side routes (`/settings`, `/projects/42`) still all
+  resolve to the SPA entry point. Both the fallback `index.html` and the
+  per-path probe results are served from per-version caches (see
+  [Performance](#performance-review)), so a deep-linked route doesn't pay a
+  second R2 read on every request.
 
 ### How assets are stored & versioned
 

package/dist/{docs-BV9qhLJx.mjs → docs-BBMVxVta.mjs}

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

package/dist/{egress-CN_axsAN.mjs → egress-BFSwa8Uu.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-2mrJcjYC.mjs";
+import { c as apiRequest, n as reportErrors } from "./ui-B1Px5y7q.mjs";
 import { defineCommand } from "citty";
 //#region src/egress.ts
 /**

package/dist/{feedback-Cb8ccQ_R.mjs → feedback-BMX_d4KZ.mjs}

@@ -1,6 +1,6 @@
-import { t as version } from "./package-BBpw-n7k.mjs";
+import { t as version } from "./package-vJXq4RNN.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 { c as apiRequest, l as apiUpload, n as reportErrors, s as apiDownload } from "./ui-B1Px5y7q.mjs";
 import { defineCommand } from "citty";
 import { basename, extname, join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-BBpw-n7k.mjs";
+import { t as version } from "./package-vJXq4RNN.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,30 @@ const main = defineCommand({
 		description: "canopy — create and deploy vibecoded projects"
 	},
 	subCommands: {
-		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-BCtEY1is.mjs").then((m) => m.deployCommand),
-		promote: () => import("./deploy-BCtEY1is.mjs").then((m) => m.promoteCommand),
-		staging: () => import("./staging-Bw1D_J8M.mjs").then((m) => m.stagingCommand),
-		rollback: () => import("./deploy-BCtEY1is.mjs").then((m) => m.rollbackCommand),
-		download: () => import("./deploy-BCtEY1is.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-Cb8ccQ_R.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-BV9qhLJx.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-DJHlTEhS.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-B86Ao6T5.mjs").then((m) => m.upgradeCommand),
-		logs: () => import("./logs-DNiZquki.mjs").then((m) => m.logsCommand)
+		login: () => import("./login-BDTO3nVw.mjs").then((m) => m.loginCommand),
+		whoami: () => import("./login-BDTO3nVw.mjs").then((m) => m.whoamiCommand),
+		logout: () => import("./login-BDTO3nVw.mjs").then((m) => m.logoutCommand),
+		create: () => import("./projects-MMbv7MmK.mjs").then((m) => m.createCommand),
+		init: () => import("./projects-MMbv7MmK.mjs").then((m) => m.initCommand),
+		projects: () => import("./projects-MMbv7MmK.mjs").then((m) => m.projectsCommand),
+		delete: () => import("./projects-MMbv7MmK.mjs").then((m) => m.deleteCommand),
+		dev: () => import("./dev-BqLvttKc.mjs").then((m) => m.devCommand),
+		deploy: () => import("./deploy-CnxJ4TE6.mjs").then((m) => m.deployCommand),
+		promote: () => import("./deploy-CnxJ4TE6.mjs").then((m) => m.promoteCommand),
+		staging: () => import("./staging-D8G4amjO.mjs").then((m) => m.stagingCommand),
+		rollback: () => import("./deploy-CnxJ4TE6.mjs").then((m) => m.rollbackCommand),
+		download: () => import("./deploy-CnxJ4TE6.mjs").then((m) => m.downloadCommand),
+		token: () => import("./token-BUxgRJVA.mjs").then((m) => m.tokenCommand),
+		egress: () => import("./egress-BFSwa8Uu.mjs").then((m) => m.egressCommand),
+		schedule: () => import("./schedule-Cq9K0rnE.mjs").then((m) => m.scheduleCommand),
+		feedback: () => import("./feedback-BMX_d4KZ.mjs").then((m) => m.feedbackCommand),
+		db: () => import("./db-DKnJQPm5.mjs").then((m) => m.dbCommand),
+		usage: () => import("./usage-DjNngyvy.mjs").then((m) => m.usageCommand),
+		open: () => import("./open-C5x3tX6I.mjs").then((m) => m.openCommand),
+		docs: () => import("./docs-BBMVxVta.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-Zq9aIPKf.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-ES8u8_Pn.mjs").then((m) => m.upgradeCommand),
+		logs: () => import("./logs-C53y2eAS.mjs").then((m) => m.logsCommand)
 	}
 });
 if (process.argv[2] !== "upgrade") notifyOfUpdate(version);