@mediamonks/canopy-cli 0.7.14 → 0.7.15

package/dist/docs/cli-egress.md

@@ -14,6 +14,9 @@ canopy egress list
 canopy egress allow api.example.com
 canopy egress allow "*.googleapis.com"
 canopy egress remove api.example.com
+canopy egress mode open --accept-risk
+canopy egress mode allowlist
+canopy egress log
 ```
 
 ## Arguments & flags
@@ -26,6 +29,12 @@ target directory, or `--project <slug>` to override — and honor the global
 - `allow <host>` — add a hostname (or `*.` subdomain wildcard; quote it so the
   shell doesn't expand the `*`).
 - `remove <host>` — remove an entry (as shown by `list`).
+- `mode [allowlist|open]` — show or switch the
+  [egress mode](https://docs.canopy.website/platform/egress#open-mode). Switching to `open` prints a risk
+  summary and asks you to type the project slug; pass `--accept-risk` to
+  acknowledge it non-interactively. Switching back needs no ceremony.
+- `log` — print the [outbound traffic log](https://docs.canopy.website/platform/egress#the-outbound-traffic-log):
+  hosts the worker actually fetched, with counts and last-seen times.
 
 ## How it works
 

package/dist/docs/cli-index.md

@@ -39,23 +39,6 @@ Canopy authenticates through Monks' OneLogin. Run [`canopy login`](https://docs.
 
 ## Commands
 
-- [canopy login](https://docs.canopy.website/cli/login) — sign in through OneLogin in your browser
-- [canopy whoami](https://docs.canopy.website/cli/whoami) — show who you're signed in as, per site
-- [canopy logout](https://docs.canopy.website/cli/logout) — clear stored tokens
-- [canopy create](https://docs.canopy.website/cli/create) — scaffold and register a new project
-- [canopy init](https://docs.canopy.website/cli/init) — set up a folder for an existing project
-- [canopy projects](https://docs.canopy.website/cli/projects) — list your projects
-- [canopy delete](https://docs.canopy.website/cli/delete) — delete a project and its data
-- [canopy dev](https://docs.canopy.website/cli/dev) — run a project locally
-- [canopy deploy](https://docs.canopy.website/cli/deploy) — build and deploy a new version
-- [canopy rollback](https://docs.canopy.website/cli/rollback) — make a previous version live again
-- [canopy download](https://docs.canopy.website/cli/download) — download a deployed version's files
-- [canopy token](https://docs.canopy.website/cli/token) — manage deploy tokens for CI
-- [canopy db](https://docs.canopy.website/cli/db) — pull, snapshot, and restore project data
-- [canopy usage](https://docs.canopy.website/cli/usage) — AI spend and storage for a project
-- [canopy open](https://docs.canopy.website/cli/open) — open the live project in your browser
-- [canopy docs](https://docs.canopy.website/cli/docs) — read the Canopy guides, offline-capable
-- [canopy skill](https://docs.canopy.website/cli/skill) — install the Canopy agent skill into a repo
-- [canopy upgrade](https://docs.canopy.website/cli/upgrade) — update the CLI itself
-
-`canopy logs` (tail a project's worker logs) exists as a stub for a planned feature and currently exits with a pointer to the roadmap.
+{/* Generated from this folder's meta.json + each page's frontmatter description — never hand-edit a list here. */}
+
+<SectionIndex folder="/cli" />

package/dist/docs/cli-schedule.md

@@ -0,0 +1,43 @@
+---
+title: canopy schedule
+description: List, add, and remove the project's cron schedules from the terminal.
+---
+
+`canopy schedule` manages the project's named cron jobs — the same schedules
+as the dashboard's **Settings → Schedules**, so a migration or an agent can
+set up recurring jobs without leaving the terminal. See
+[Schedules](https://docs.canopy.website/platform/schedules) for how schedules work and how your worker
+handles them.
+
+## Usage
+
+```bash
+canopy schedule list
+canopy schedule add refresh-feeds "0 5 * * *"
+canopy schedule remove refresh-feeds
+```
+
+## Arguments & flags
+
+All subcommands resolve the project the usual way — `canopy.json` in the
+target directory, or `--project <slug>` to override — and honor the global
+`--profile <site>` / `CANOPY_PROFILE`.
+
+- `list` — print each schedule with its cron expression, enabled state, and
+  last run (including the error when the last run failed). `--json` prints
+  the raw JSON instead.
+- `add <name> <cron>` — create a schedule, or update the cron of an existing
+  one. Names are lowercase letters, digits, and hyphens; the cron is a
+  standard five-field expression in **UTC** — quote it so the shell doesn't
+  expand the `*`s.
+- `remove <name>` — delete a schedule (as shown by `list`).
+
+## How it works
+
+Schedules live on the platform, per project — not in `canopy.json` — so
+changing a cadence never needs a deploy. A project can have up to **5
+schedules** with a shortest interval of one minute; names and cron
+expressions are validated server-side. Your worker receives ticks in its
+`scheduled` handler and switches on `event.name` — see
+[Schedules](https://docs.canopy.website/platform/schedules). Enabling/disabling without deleting, and
+firing a job manually to test it, remain dashboard-only for now.

package/dist/docs/index.json

@@ -112,12 +112,12 @@
         {
           "slug": "platform-schedules",
           "title": "Schedules",
-          "summary": "Run named cron jobs in your project's backend — configured in the dashboard, so you can change the cadence without redeploying."
+          "summary": "Run named cron jobs in your project's backend — configured in the dashboard or the CLI, so you can change the cadence without redeploying."
         },
         {
           "slug": "platform-egress",
           "title": "Outbound requests",
-          "summary": "Which external hosts your project's backend may fetch — a per-project allowlist you manage yourself."
+          "summary": "Which external hosts your project's backend may fetch — a per-project allowlist you manage yourself, or open mode for apps that fetch arbitrary URLs."
         },
         {
           "slug": "platform-ai-usage",
@@ -236,6 +236,11 @@
           "title": "canopy egress",
           "summary": "Manage which outbound hosts the project's backend worker may fetch."
         },
+        {
+          "slug": "cli-schedule",
+          "title": "canopy schedule",
+          "summary": "List, add, and remove the project's cron schedules from the terminal."
+        },
         {
           "slug": "cli-db",
           "title": "canopy db",
@@ -308,6 +313,11 @@
           "title": "AI",
           "summary": "Metered LLM access through the project's budget-capped gateway key — chat, streaming, and an OpenAI-compatible endpoint."
         },
+        {
+          "slug": "sdk-google",
+          "title": "Google",
+          "summary": "Call Google APIs as the project's connected account or as the visitor's own — the platform holds the OAuth."
+        },
         {
           "slug": "sdk-services",
           "title": "Services",

package/dist/docs/platform-egress.md

@@ -1,6 +1,6 @@
 ---
 title: Outbound requests
-description: Which external hosts your project's backend may fetch — a per-project allowlist you manage yourself.
+description: Which external hosts your project's backend may fetch — a per-project allowlist you manage yourself, or open mode for apps that fetch arbitrary URLs.
 ---
 
 Outbound `fetch` from a project's backend worker is **deny-by-default**: the
@@ -73,3 +73,54 @@ how recently each was hit. One click on **Allow** puts the host on the list
 and clears it from the blocked section. Hosts that keep a low profile drop
 off — the list remembers the 50 most recent — and allowing a host removes its
 blocked entry immediately.
+
+## Open mode
+
+Some apps exist to fetch **arbitrary user-provided URLs** — link collectors,
+feed readers, scrapers. For those, an allowlist is the wrong shape: the long
+tail of domains never ends, and every new one is a denied request. Instead of
+growing the list forever, switch the project to **open egress mode**:
+
+```bash
+canopy egress mode open
+```
+
+or in the dashboard: **Settings → Outbound hosts → Egress mode**. In open mode
+the worker may fetch **any public hostname**. Three guardrails replace the
+allowlist:
+
+- **A built-in blocklist**, no exceptions: IP-literal URLs (v4 and v6),
+  `localhost`, private networks, and cloud metadata endpoints
+  (`metadata.google.internal` and friends) are always denied — in both modes.
+- **An outbound rate limit** — generous (hundreds of fetches per minute; it
+  exists to stop runaway loops and hostile scraping, not to meter normal use).
+  Exceeding it answers 403 with `egress_rate_limited`, and the hits show up
+  under Recently blocked. If your app legitimately needs more, tell us —
+  the budget is meant to be raised when real use bumps into it.
+- **The outbound traffic log** (below) records every host the worker talks to.
+
+Because open mode means _users of your app can decide where it connects_,
+enabling it is a deliberate act: the dashboard asks you to type the project
+slug under a plain-language risk summary, and the CLI wants an interactive
+confirmation or the explicit `--accept-risk` flag. Extra care applies if the
+project has [client access](https://docs.canopy.website/platform/client-access) enabled — then untrusted
+visitors drive the fetches.
+
+Switching back is one command (`canopy egress mode allowlist`), and the
+dashboard offers to **seed the allowlist from the observed hosts** so
+tightening up later doesn't break the app.
+
+## The outbound traffic log
+
+In both modes, the platform keeps a per-project log of the hosts the worker
+**actually fetched** — hostnames only, never paths, query strings, headers, or
+bodies. Per host it tracks a fetch count and first/last seen. See it under
+**Outbound traffic** in Settings → Outbound hosts, or:
+
+```bash
+canopy egress log
+```
+
+In allowlist mode it doubles as a shortcut: any observed host can be promoted
+to the allowlist with one click. The log keeps up to 1000 distinct hosts per
+project; beyond that the least-recently-seen entry makes room.

package/dist/docs/platform-google.md

@@ -9,7 +9,8 @@ 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.
+holds all of that. This page covers the concepts and permissions; the calling
+surface is documented in [the SDK reference](https://docs.canopy.website/sdk/google).
 
 ## The project's own account
 

package/dist/docs/platform-schedules.md

@@ -1,12 +1,13 @@
 ---
 title: Schedules
-description: Run named cron jobs in your project's backend — configured in the dashboard, so you can change the cadence without redeploying.
+description: Run named cron jobs in your project's backend — configured in the dashboard or the CLI, 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.
+cache every hour, tick a counter every minute. You define **named jobs** —
+in the dashboard or with [`canopy schedule`](https://docs.canopy.website/cli/schedule) — 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
@@ -28,6 +29,18 @@ 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.
 
+The same jobs are manageable from the terminal — handy when a migration or a
+coding agent sets up a project end to end:
+
+```bash
+canopy schedule list
+canopy schedule add refresh-feeds "0 5 * * *"
+canopy schedule remove refresh-feeds
+```
+
+See [canopy schedule](https://docs.canopy.website/cli/schedule) for the details. Pausing a job and
+firing one manually are dashboard-only.
+
 ## Handling schedules in your code
 
 Your project's worker exports a `scheduled` handler next to its normal

package/dist/docs/sdk-google.md

@@ -0,0 +1,139 @@
+---
+title: Google
+description: Call Google APIs as the project's connected account or as the visitor's own — the platform holds the OAuth.
+---
+
+`canopy.google` calls Google APIs through the platform — no client IDs,
+secrets, redirect URLs, or tokens in project code. There are two grants,
+chosen explicitly because they act as different accounts:
+
+```ts
+canopy.google.project(); // the account the owner connected — backend only
+canopy.google.user(); // the calling visitor's own account
+```
+
+What each grant is for, who connects one, and every permission bundle is
+covered in [Google](https://docs.canopy.website/platform/google) on the platform side — this page is the
+calling surface. Both grants share the same three calls; the user grant adds
+the connect flow.
+
+## grant.status()
+
+Whether this grant is usable right now — check it before offering a feature:
+
+```ts
+const status = await canopy.google.user().status();
+if (!status.connected) {
+  // show a connect button
+}
+```
+
+| Field        | Type              | Meaning                                                                                                                                                               |
+| ------------ | ----------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `configured` | `boolean`         | Whether this Canopy site has Google set up at all.                                                                                                                    |
+| `connected`  | `boolean`         | Whether an account is connected on this grant.                                                                                                                        |
+| `available`  | `boolean?`        | Whether this caller could use the grant at all — `false` for the project grant in a browser, or the user grant in a scheduled job. A fact to branch on, not an error. |
+| `reason`     | `string?`         | Why the grant is unavailable, when it is.                                                                                                                             |
+| `email`      | `string?`         | Which account acts when this grant is used.                                                                                                                           |
+| `bundles`    | `string[]?`       | Permission bundles the grant can actually use. Google lets people approve a subset of what was asked, so branch on this, not on what you requested.                   |
+| `requested`  | `string[]?`       | What was asked for. Anything here but missing from `bundles` needs a reconnect.                                                                                       |
+| `catalog`    | `GoogleBundle[]?` | Everything that could be connected — key, label, description, tier — for building your own connect prompt.                                                            |
+
+## grant.fetch(url, init?)
+
+Call a Google API URL and get its JSON response back, typed with the generic
+you provide:
+
+```ts
+const sheet = await canopy.google
+  .project()
+  .fetch("https://sheets.googleapis.com/v4/spreadsheets/<id>/values/A1:C10");
+
+const event = await canopy.google
+  .user()
+  .fetch<CalendarEvent>("https://www.googleapis.com/calendar/v3/calendars/primary/events", {
+    method: "POST",
+    body: { summary: "Sync", start, end },
+  });
+```
+
+- `url` — a full Google API URL, straight from Google's own API reference.
+- `init.method` — `GET` (default), `POST`, `PUT`, `PATCH`, or `DELETE`.
+- `init.headers` — optional; only `content-type`, `accept`, and `accept-language` reach Google.
+- `init.body` — objects are JSON-encoded; strings are sent as-is.
+
+Which URLs work depends on the permission bundles the grant holds — a call
+outside them (or a write on a reading-only bundle) is refused before it
+reaches Google and throws `CanopyError`.
+
+## grant.raw(url, init?)
+
+The same call, returning the raw `Response` — for endpoints that answer with
+bytes rather than JSON, like a Drive file download or an exported document:
+
+```ts
+const res = await canopy.google
+  .project()
+  .raw("https://www.googleapis.com/drive/v3/files/<id>?alt=media");
+const pdf = await res.blob();
+```
+
+## Connecting a visitor (user grant only)
+
+The project grant is connected once, by the owner, on the dashboard's
+**Services** tab — there is no code involved. Visitors connect themselves,
+from your pages:
+
+```ts
+const google = canopy.google.user();
+
+// On load: did we just come back from a connect trip?
+const result = google.consumeConnectResult(); // toast this, if not null
+
+const status = await google.status();
+if (!status.connected) {
+  google.connect(["calendar-read"]); // full-page trip to Google, then back here
+}
+```
+
+### user.connect(bundles, returnTo?)
+
+Sends the browser to Google's consent screen — a full-page navigation, not a
+fetch, so put the button somewhere without unsaved work. `bundles` is the list
+of permission bundle keys to ask for (e.g. `"sheets-read"`, `"calendar"`,
+`"gmail-send"` — the picker on the Services tab shows every key, and
+`status().catalog` lists them at runtime). `returnTo` defaults to the current
+page. Browser only — calling it in a worker throws.
+
+### user.connectUrl(bundles, returnTo?)
+
+The URL `connect()` navigates to, when you want to render it yourself as a
+plain link.
+
+### user.consumeConnectResult()
+
+Reads the one-shot outcome the connect flow left in the URL and strips it, so
+a refresh doesn't replay it. Returns `null` when this page load wasn't a
+return trip:
+
+```ts
+const result = google.consumeConnectResult();
+// { ok: true, email: "…" } | { ok: false, reason: "cancelled" | … } | null
+```
+
+Call it on load and show a message when it isn't null. After the trip,
+`status()` is the reliable answer to "are they connected" — this only tells
+you how the trip that just happened went.
+
+### user.disconnect()
+
+Drops the visitor's connection and revokes it at Google, so access stops
+immediately:
+
+```ts
+await canopy.google.user().disconnect();
+```
+
+> **Note:** The user grant also works in worker code that is handling that visitor's request — same account,
+> same calls. It cannot work in a scheduled job, because then nobody is signed in; that is what the
+> project grant is for.

package/dist/docs/sdk.md

@@ -4,8 +4,8 @@ description: One typed client for auth, data, files, AI, and services — no key
 ---
 
 `@mediamonks/canopy` is a thin, typed client over the platform's project API.
-One `createCanopy()` call gives you five modules — `auth`, `db`, `blob`, `ai`,
-and `services` — and that is the entire surface. There are no API keys,
+One `createCanopy()` call gives you six modules — `auth`, `db`, `blob`, `ai`,
+`google`, and `services` — and that is the entire surface. There are no API keys,
 connection strings, or environment variables to manage: every call rides the
 session the platform already established before your code ran.
 
@@ -35,7 +35,7 @@ import { createCanopy } from "/_api/data/v1/sdk.js";
 import { createCanopy } from "@mediamonks/canopy";
 
 const canopy = createCanopy();
-// canopy.auth, canopy.db, canopy.blob, canopy.ai, canopy.services
+// canopy.auth, canopy.db, canopy.blob, canopy.ai, canopy.google, canopy.services
 ```
 
 | Option    | Type           | Default        | What it does                                                                                                          |
@@ -119,8 +119,6 @@ environments:
 
 ## Modules
 
-- [Auth](https://docs.canopy.website/sdk/auth) — who is signed in, and ending sessions.
-- [Database](https://docs.canopy.website/sdk/database) — document collections, plus a raw SQL escape hatch.
-- [Files](https://docs.canopy.website/sdk/files) — private blob storage under the project's prefix.
-- [AI](https://docs.canopy.website/sdk/ai) — metered, budget-capped LLM access.
-- [Services](https://docs.canopy.website/sdk/services) — curated internal data services.
+{/* Generated from this folder's meta.json + each page's frontmatter description — never hand-edit a list here. */}
+
+<SectionIndex folder="/sdk" />

package/dist/{docs-3pQHiuTn.mjs → docs-BlzdYmou.mjs}

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

package/dist/egress-PJp0SZy2.mjs

@@ -0,0 +1,184 @@
+import { a as projectDirArgs, c as resolveProject } from "./site-BUlQR117.mjs";
+import { c as apiRequest, i as unwrap, n as reportErrors, r as requireTty } from "./ui-B1Px5y7q.mjs";
+import { defineCommand } from "citty";
+import * as p from "@clack/prompts";
+//#region src/egress.ts
+/**
+* canopy egress — manage the project's outbound-host policy: the allowlist
+* (docs/16-egress-allowlist.md) and the egress mode (docs/25-egress-modes.md).
+* In allowlist mode, worker fetches to hosts outside the list are denied
+* (`egress_denied`) on targets that enforce egress control; open mode allows
+* any public hostname behind a built-in blocklist and an outbound rate limit.
+* Policy lives on the platform, not in canopy.json, so a repo file can never
+* widen egress silently on deploy.
+*/
+function printList({ mode, hosts, denied, enforced }, slug) {
+	if (mode === "open") console.log(`${slug} is in OPEN egress mode — the worker may fetch any public host (the allowlist below is kept but not enforced; \`canopy egress mode allowlist\` restores it).`);
+	if (hosts.length === 0) console.log(`No extra egress hosts for ${slug} — the worker can reach platform hosts only.`);
+	else for (const host of hosts) console.log(host);
+	if (denied.length > 0) {
+		console.log(`\nRecently blocked (allow with \`canopy egress allow <host>\`):`);
+		for (const d of denied) {
+			const why = d.reason === "rate_limited" ? "rate limited" : "blocked";
+			console.log(`  ${d.host}  ×${d.count}  ${why}, last ${d.last_seen}`);
+		}
+	}
+	if (!enforced) console.error("(note: this site's target does not enforce egress yet — the policy is recorded for when it does)");
+}
+const listCommand = defineCommand({
+	meta: {
+		name: "list",
+		description: "List the project's allowed outbound hosts"
+	},
+	args: { ...projectDirArgs },
+	run: reportErrors("egress list", async ({ args }) => {
+		const { slug } = resolveProject(args);
+		printList(await apiRequest("GET", `/projects/${slug}/egress`), slug);
+	})
+});
+const allowCommand = defineCommand({
+	meta: {
+		name: "allow",
+		description: "Allow the worker to fetch a host (e.g. api.example.com or *.googleapis.com)"
+	},
+	args: {
+		host: {
+			type: "positional",
+			description: "Hostname to allow",
+			required: true
+		},
+		...projectDirArgs
+	},
+	run: reportErrors("egress allow", async ({ args }) => {
+		const { slug } = resolveProject(args);
+		const current = await apiRequest("GET", `/projects/${slug}/egress`);
+		const updated = await apiRequest("PUT", `/projects/${slug}/egress`, { hosts: [...current.hosts, args.host] });
+		console.log(`Allowed ${args.host} for ${slug} — running workers pick it up now.\n`);
+		printList(updated, slug);
+	})
+});
+const removeCommand = defineCommand({
+	meta: {
+		name: "remove",
+		description: "Remove a host from the allowlist"
+	},
+	args: {
+		host: {
+			type: "positional",
+			description: "Hostname to remove",
+			required: true
+		},
+		...projectDirArgs
+	},
+	run: reportErrors("egress remove", async ({ args }) => {
+		const { slug } = resolveProject(args);
+		const current = await apiRequest("GET", `/projects/${slug}/egress`);
+		const wanted = args.host.trim().toLowerCase();
+		if (!current.hosts.includes(wanted)) {
+			console.error(`${wanted} is not on the allowlist for ${slug} (see \`canopy egress list\`).`);
+			process.exit(1);
+		}
+		const updated = await apiRequest("PUT", `/projects/${slug}/egress`, { hosts: current.hosts.filter((h) => h !== wanted) });
+		console.log(`Removed ${wanted} from ${slug} — running workers stop reaching it now.\n`);
+		printList(updated, slug);
+	})
+});
+/** The plain-language risk summary shown before open mode is enabled (docs/25 §2). */
+function openModeRiskSummary(slug, clientAccess) {
+	const lines = [
+		`Open egress mode lets ${slug}'s worker contact ANY public host:`,
+		"",
+		"  - If the URLs it fetches come from user input, users control where it connects.",
+		"  - Abusive outbound traffic can get the project rate-limited or paused.",
+		"  - A built-in blocklist (private IPs, localhost, cloud metadata) and an",
+		"    outbound rate limit still apply, and every visited host is logged",
+		"    (`canopy egress log`)."
+	];
+	if (clientAccess) lines.push("", "  ! This project has client access enabled — untrusted visitors can drive", "    what the worker fetches.");
+	lines.push("", "It's the right choice for apps that fetch arbitrary user-provided URLs", "(link collectors, feed readers, scrapers). Everything else is better served", "by the allowlist.");
+	return lines.join("\n");
+}
+const egressCommand = defineCommand({
+	meta: {
+		name: "egress",
+		description: "Manage which outbound hosts the project's worker may fetch"
+	},
+	subCommands: {
+		list: listCommand,
+		allow: allowCommand,
+		remove: removeCommand,
+		mode: defineCommand({
+			meta: {
+				name: "mode",
+				description: "Show or switch the egress mode (allowlist | open)"
+			},
+			args: {
+				mode: {
+					type: "positional",
+					description: "allowlist | open (omit to show)",
+					required: false
+				},
+				"accept-risk": {
+					type: "boolean",
+					description: "Acknowledge the open-mode risk summary without an interactive prompt"
+				},
+				...projectDirArgs
+			},
+			run: reportErrors("egress mode", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const current = await apiRequest("GET", `/projects/${slug}/egress`);
+				const wanted = args.mode?.trim().toLowerCase();
+				if (!wanted) {
+					console.log(current.mode);
+					return;
+				}
+				if (wanted !== "allowlist" && wanted !== "open") {
+					console.error(`unknown mode "${wanted}" — expected allowlist or open.`);
+					process.exit(1);
+				}
+				if (wanted === current.mode) {
+					console.log(`${slug} is already in ${wanted} mode.`);
+					return;
+				}
+				if (wanted === "open") {
+					const access = await apiRequest("GET", `/projects/${slug}/client-password`).catch(() => ({ enabled: false }));
+					console.log(openModeRiskSummary(slug, access.enabled));
+					console.log("");
+					if (!args["accept-risk"]) {
+						requireTty("pass --accept-risk to enable open mode without confirmation.");
+						if (unwrap(await p.text({ message: `Type the project slug ("${slug}") to enable open mode.` })).trim() !== slug) {
+							p.cancel("Aborted — egress mode unchanged.");
+							return;
+						}
+					}
+				}
+				const updated = await apiRequest("PUT", `/projects/${slug}/egress`, { mode: wanted });
+				if (wanted === "open") {
+					console.log(`Open egress mode is ON for ${slug} — running workers pick it up now.`);
+					console.log(`Switch back anytime with \`canopy egress mode allowlist\`.`);
+				} else {
+					console.log(`Allowlist mode restored for ${slug} — only listed hosts are reachable.\n`);
+					printList(updated, slug);
+				}
+			})
+		}),
+		log: defineCommand({
+			meta: {
+				name: "log",
+				description: "Show the outbound traffic log — hosts the worker actually fetched"
+			},
+			args: { ...projectDirArgs },
+			run: reportErrors("egress log", async ({ args }) => {
+				const { slug } = resolveProject(args);
+				const { visits } = await apiRequest("GET", `/projects/${slug}/egress/log`);
+				if (visits.length === 0) {
+					console.log(`No outbound traffic recorded for ${slug} yet.`);
+					return;
+				}
+				for (const v of visits) console.log(`${v.host}  ×${v.count}  last ${v.last_seen}`);
+			})
+		})
+	}
+});
+//#endregion
+export { egressCommand };

package/dist/{feedback-DReTDDzD.mjs → feedback-h_j6DBBZ.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-CuyFMXam.mjs";
+import { t as version } from "./package-CF0dX7UA.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-B1Px5y7q.mjs";
 import { defineCommand } from "citty";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-CuyFMXam.mjs";
+import { t as version } from "./package-CF0dX7UA.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";
@@ -74,15 +74,15 @@ const main = defineCommand({
 		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),
+		egress: () => import("./egress-PJp0SZy2.mjs").then((m) => m.egressCommand),
 		schedule: () => import("./schedule-Cq9K0rnE.mjs").then((m) => m.scheduleCommand),
-		feedback: () => import("./feedback-DReTDDzD.mjs").then((m) => m.feedbackCommand),
+		feedback: () => import("./feedback-h_j6DBBZ.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-3pQHiuTn.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-M4RHvuUB.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-C8Xox-P-.mjs").then((m) => m.upgradeCommand),
+		docs: () => import("./docs-BlzdYmou.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-DaaxgqEk.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-DG-7xwOs.mjs").then((m) => m.upgradeCommand),
 		logs: () => import("./logs-C53y2eAS.mjs").then((m) => m.logsCommand)
 	}
 });

package/dist/{package-CuyFMXam.mjs → package-CF0dX7UA.mjs}

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

package/dist/{skill-M4RHvuUB.mjs → skill-DaaxgqEk.mjs}

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

package/dist/{upgrade-C8Xox-P-.mjs → upgrade-DG-7xwOs.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-M4RHvuUB.mjs");
+		const { skillInstalled } = await import("./skill-DaaxgqEk.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.14",
+  "version": "0.7.15",
   "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": "0.0.5",
-    "@mediamonks/canopy-data-plane": "0.0.4"
+    "@mediamonks/canopy-data-plane": "0.0.4",
+    "@mediamonks/canopy": "0.0.5"
   },
   "devDependencies": {
     "@types/node": "^26.1.1",

package/dist/egress-BFSwa8Uu.mjs

@@ -1,88 +0,0 @@
-import { a as projectDirArgs, c as resolveProject } from "./site-BUlQR117.mjs";
-import { c as apiRequest, n as reportErrors } from "./ui-B1Px5y7q.mjs";
-import { defineCommand } from "citty";
-//#region src/egress.ts
-/**
-* canopy egress — manage the project's outbound-host allowlist
-* (docs/16-egress-allowlist.md). Worker fetches to hosts outside the list are
-* denied (`egress_denied`) on targets that enforce egress control; the list
-* lives on the platform, not in canopy.json, so a repo file can never widen
-* egress silently on deploy.
-*/
-function printList({ hosts, denied, enforced }, slug) {
-	if (hosts.length === 0) console.log(`No extra egress hosts for ${slug} — the worker can reach platform hosts only.`);
-	else for (const host of hosts) console.log(host);
-	if (denied.length > 0) {
-		console.log(`\nRecently blocked (allow with \`canopy egress allow <host>\`):`);
-		for (const d of denied) console.log(`  ${d.host}  ×${d.count}  last ${d.last_seen}`);
-	}
-	if (!enforced) console.error("(note: this site's target does not enforce egress yet — the list is recorded for when it does)");
-}
-const egressCommand = defineCommand({
-	meta: {
-		name: "egress",
-		description: "Manage which outbound hosts the project's worker may fetch"
-	},
-	subCommands: {
-		list: defineCommand({
-			meta: {
-				name: "list",
-				description: "List the project's allowed outbound hosts"
-			},
-			args: { ...projectDirArgs },
-			run: reportErrors("egress list", async ({ args }) => {
-				const { slug } = resolveProject(args);
-				printList(await apiRequest("GET", `/projects/${slug}/egress`), slug);
-			})
-		}),
-		allow: defineCommand({
-			meta: {
-				name: "allow",
-				description: "Allow the worker to fetch a host (e.g. api.example.com or *.googleapis.com)"
-			},
-			args: {
-				host: {
-					type: "positional",
-					description: "Hostname to allow",
-					required: true
-				},
-				...projectDirArgs
-			},
-			run: reportErrors("egress allow", async ({ args }) => {
-				const { slug } = resolveProject(args);
-				const current = await apiRequest("GET", `/projects/${slug}/egress`);
-				const updated = await apiRequest("PUT", `/projects/${slug}/egress`, { hosts: [...current.hosts, args.host] });
-				console.log(`Allowed ${args.host} for ${slug} — running workers pick it up now.\n`);
-				printList(updated, slug);
-			})
-		}),
-		remove: defineCommand({
-			meta: {
-				name: "remove",
-				description: "Remove a host from the allowlist"
-			},
-			args: {
-				host: {
-					type: "positional",
-					description: "Hostname to remove",
-					required: true
-				},
-				...projectDirArgs
-			},
-			run: reportErrors("egress remove", async ({ args }) => {
-				const { slug } = resolveProject(args);
-				const current = await apiRequest("GET", `/projects/${slug}/egress`);
-				const wanted = args.host.trim().toLowerCase();
-				if (!current.hosts.includes(wanted)) {
-					console.error(`${wanted} is not on the allowlist for ${slug} (see \`canopy egress list\`).`);
-					process.exit(1);
-				}
-				const updated = await apiRequest("PUT", `/projects/${slug}/egress`, { hosts: current.hosts.filter((h) => h !== wanted) });
-				console.log(`Removed ${wanted} from ${slug} — running workers stop reaching it now.\n`);
-				printList(updated, slug);
-			})
-		})
-	}
-});
-//#endregion
-export { egressCommand };