@mediamonks/canopy-cli 0.7.34 → 0.7.36

package/dist/{dev-CGSIY1-y.mjs → dev-BdXslHoA.mjs}

@@ -2,12 +2,13 @@ import { a as projectDirArgs, c as resolveProject, i as projectDialect, n as sit
 import { i as apiRequest, o as withContext, t as ApiError } from "./api-C4rMhE7i.mjs";
 import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";
 import { r as readMigrationFiles } from "./migrations-Czlcddyz.mjs";
-import { r as stampWorkerHeaders } from "./src-DE37PKho.mjs";
+import { i as stampWorkerHeaders, n as WORKER_ATTEST_HEADER } from "./src-CxzGOEhP.mjs";
 import { n as writeDevServerRecord } from "./dev-server-file-Dk9pk4AR.mjs";
 import { createRequire } from "node:module";
 import { defineCommand } from "citty";
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import { randomBytes } from "node:crypto";
 import { pathToFileURL } from "node:url";
 //#region src/dev.ts
 /**
@@ -33,28 +34,30 @@ function workerDialect(flags) {
 * gateway serves it in production (dev-worker.ts). Returns the plugin plus
 * the notice lines to print, or undefined when the project has no worker.
 */
-async function workerPlugin(flags, slug) {
+async function workerPlugin(flags, slug, workerAttest, remoteUser) {
 	const entry = tryReadCanopyJson(flags.dir)?.worker;
 	if (entry === void 0) return void 0;
 	if (!existsSync(join(flags.dir, entry))) {
 		console.log(`note: canopy.json points "worker" at ${entry}, which does not exist — skipping.`);
 		return;
 	}
-	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-JbLEXmVg.mjs");
+	const { missingSecretNames, readDevVars, workerDevPlugin } = await import("./dev-worker-CpSB_Okh.mjs");
 	const secrets = readDevVars(flags.dir);
 	const email = siteConfig().email;
+	const user = await remoteUser?.() ?? (email ? {
+		sub: "local-dev",
+		email,
+		name: "Local Dev"
+	} : null);
 	const plugin = workerDevPlugin({
 		dir: flags.dir,
 		entry,
 		slug,
 		channel: flags.staging ? "staging" : "live",
 		secrets,
-		user: email ? {
-			sub: "local-dev",
-			email,
-			name: "Local Dev"
-		} : null,
-		dialect: workerDialect(flags)
+		user,
+		dialect: workerDialect(flags),
+		workerAttest
 	});
 	const notes = [`  /api/* is served by ${entry} (edit and refresh; no build step)`];
 	if (Object.keys(secrets).length > 0) notes.push(`  worker secrets from .dev.vars: ${Object.keys(secrets).sort().join(", ")}`);
@@ -154,6 +157,26 @@ function devProxyHeaders(token, slug, channel) {
 	return Object.fromEntries(headers);
 }
 /**
+* The signed-in person as the platform sees them — what auth.user() answers
+* in the browser, so env.USER in a live-data dev worker matches it.
+* Undefined on any failure: dev still starts, with the local stub.
+*/
+async function fetchDevUser(apiUrl, headers) {
+	try {
+		const res = await fetch(`${apiUrl}/data/v1/auth/me`, { headers });
+		if (!res.ok) return void 0;
+		const me = await res.json();
+		if (!me.id) return void 0;
+		return {
+			sub: me.id,
+			email: me.email ?? "",
+			name: me.name ?? ""
+		};
+	} catch {
+		return;
+	}
+}
+/**
 * One request from Vite's /_api proxy into the --local sandbox. The response
 * body is streamed, not buffered — realtime subscriptions (docs/48) are
 * long-lived SSE responses — and a client that goes away aborts the sandbox
@@ -168,6 +191,8 @@ async function bridgeToSandbox(sandbox, req, res) {
 	const headers = new Headers();
 	if (req.headers["content-type"]) headers.set("content-type", req.headers["content-type"]);
 	if (req.headers["accept"]) headers.set("accept", req.headers["accept"]);
+	const attest = req.headers[WORKER_ATTEST_HEADER];
+	if (typeof attest === "string") headers.set(WORKER_ATTEST_HEADER, attest);
 	const response = await sandbox.handle(new Request(`http://canopy.local${req.url ?? ""}`, {
 		method: req.method,
 		headers,
@@ -198,11 +223,12 @@ async function bridgeToSandbox(sandbox, req, res) {
 async function devRemote(flags, slug) {
 	const { token, expires_at } = await withContext(apiRequest("POST", `/projects/${slug}/dev-token`), devTokenContext(slug));
 	const { apiUrl } = siteConfig();
-	const worker = await workerPlugin(flags, slug);
+	const channel = flags.staging ? "staging" : "live";
+	const worker = await workerPlugin(flags, slug, void 0, () => fetchDevUser(apiUrl, devProxyHeaders(token, slug, channel)));
 	const server = await startVite(flags, { proxy: { "/_api": {
 		target: apiUrl,
 		changeOrigin: true,
-		headers: devProxyHeaders(token, slug, flags.staging ? "staging" : "live"),
+		headers: devProxyHeaders(token, slug, channel),
 		rewrite: rewriteApiPath
 	} } }, worker ? [worker.plugin] : []);
 	if (flags.staging) {
@@ -225,7 +251,7 @@ async function devRemote(flags, slug) {
 async function devLocal(flags, slug) {
 	let dump;
 	if (flags.pull) {
-		const { fetchProjectDump } = await import("./local-qR8CBseB.mjs");
+		const { fetchProjectDump } = await import("./local-Cyl39_Zu.mjs");
 		console.log(`Pulling a fresh export of ${slug}${flags.staging ? " [staging]" : ""}…`);
 		dump = await fetchProjectDump(slug, flags.staging ? "staging" : "live");
 	}
@@ -240,12 +266,14 @@ 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-qR8CBseB.mjs");
+	const workerAttest = randomBytes(24).toString("base64url");
+	const { createSandbox } = await import("./local-Cyl39_Zu.mjs");
 	const sandbox = await createSandbox({
 		slug,
 		persistDir: join(flags.dir, ".canopy", "local"),
 		email: siteConfig().email,
-		dialect: flags.dialect
+		dialect: flags.dialect,
+		workerAttest
 	});
 	if (dump !== void 0) {
 		await sandbox.applyDump(dump);
@@ -276,7 +304,7 @@ async function devLocal(flags, slug) {
 		headers: { authorization: `Bearer ${remote.token}` },
 		rewrite: rewriteApiPath
 	};
-	const worker = await workerPlugin(flags, slug);
+	const worker = await workerPlugin(flags, slug, workerAttest);
 	const server = await startVite(flags, { proxy: {
 		...remoteEntry && {
 			"/_api/data/v1/ai": remoteEntry,
@@ -348,4 +376,4 @@ const devCommand = defineCommand({
 	})
 });
 //#endregion
-export { rewriteApiPath as i, devCommand as n, devProxyHeaders as r, bridgeToSandbox as t };
+export { rewriteApiPath as a, fetchDevUser as i, devCommand as n, devProxyHeaders as r, bridgeToSandbox as t };

package/dist/dev-BeFX_wc5.mjs

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

package/dist/{dev-worker-JbLEXmVg.mjs → dev-worker-CpSB_Okh.mjs}

@@ -1,4 +1,4 @@
-import { n as redactCanopyCredentials, r as stampWorkerHeaders, t as CALLER_HEADER } from "./src-DE37PKho.mjs";
+import { i as stampWorkerHeaders, n as WORKER_ATTEST_HEADER, r as redactCanopyCredentials, t as CALLER_HEADER } from "./src-CxzGOEhP.mjs";
 import { readFileSync } from "node:fs";
 import { relative, resolve, sep } from "node:path";
 //#region src/dev-worker.ts
@@ -97,7 +97,7 @@ function rewriteCanopyUrl(raw, base) {
 * dev server's `/_api` mount so the running mode decides what answers.
 * Credentials stay in the proxy; nothing here carries a token.
 */
-function createCanopyFetch(apiBase, slug, channel, fetchImpl = fetch) {
+function createCanopyFetch(apiBase, slug, channel, fetchImpl = fetch, workerAttest) {
 	return async (input, init) => {
 		const url = rewriteCanopyUrl(typeof input === "string" ? input : input instanceof URL ? input.href : input.url, apiBase());
 		const headers = stampWorkerHeaders(new Headers(input instanceof Request ? input.headers : init?.headers), {
@@ -106,6 +106,8 @@ function createCanopyFetch(apiBase, slug, channel, fetchImpl = fetch) {
 		});
 		headers.delete("authorization");
 		headers.delete("cookie");
+		if (workerAttest) headers.set(WORKER_ATTEST_HEADER, workerAttest);
+		else headers.delete(WORKER_ATTEST_HEADER);
 		const method = (input instanceof Request ? input.method : init?.method) ?? "GET";
 		const body = input instanceof Request ? input.body : init?.body;
 		const outbound = {
@@ -263,7 +265,7 @@ async function sendResponse(res, response) {
 function workerDevPlugin(options) {
 	const moduleId = entryModuleId(options.dir, options.entry);
 	let apiBase = "";
-	const canopyFetch = createCanopyFetch(() => apiBase, options.slug, options.channel);
+	const canopyFetch = createCanopyFetch(() => apiBase, options.slug, options.channel, fetch, options.workerAttest);
 	return {
 		name: "canopy-project-worker",
 		configureServer(server) {

package/dist/docs/cli-dev.md

@@ -25,9 +25,9 @@ canopy dev --local --pull       # sandbox hydrated from a fresh prod export
 
 ## How it works
 
-**Remote-first (default).** The CLI mints a short-lived, project-scoped dev token from the platform, then starts Vite with a proxy: every `/_api/*` request is forwarded to the real platform API with that token attached. The token stays inside the proxy — browser code never holds a credential. When the token expires (the expiry is printed at startup), restart `canopy dev`. Because you're on live data, the startup banner suggests `canopy db snapshot` before risky changes, or switching to `--local --pull`.
+**Remote-first (default).** The CLI mints a short-lived, project-scoped dev token from the platform, then starts Vite with a proxy: every `/_api/*` request is forwarded to the real platform API with that token attached. The token stays inside the proxy — browser code never holds a credential. When the token expires (the expiry is printed at startup), restart `canopy dev`. Because every call from your browser carries that token, the `private_` rule doesn't apply to your own pages in this mode; use `--local` to test it. Because you're on live data, the startup banner suggests `canopy db snapshot` before risky changes, or switching to `--local --pull`.
 
-**Local sandbox (`--local`).** Database, file, and auth requests are answered entirely on your machine, from a sandbox stored under `.canopy/local/` in the project directory — no database to install, and writes never reach the platform. The sandbox behaves the same as the real API, so code that works locally works deployed. Two things still go remote: `ai` and `services` calls go through to the real platform (metered as usual) when you're logged in — fully offline, they return errors until you log in and restart.
+**Local sandbox (`--local`).** Database, file, and auth requests are answered entirely on your machine, from a sandbox stored under `.canopy/local/` in the project directory — no database to install, and writes never reach the platform. The sandbox behaves the same as the real API, so code that works locally works deployed. That includes [`private_` collections and tables](https://docs.canopy.website/sdk/database): your pages get the same refusal they would get deployed, while your worker keeps full access. The one setting it doesn't copy is **Browser access** on the Data tab: locally, pages always get read and write. Two things still go remote: `ai` and `services` calls go through to the real platform (metered as usual) when you're logged in — fully offline, they return errors until you log in and restart.
 
 **Matching your site's SQL dialect.** The document API (`canopy.db.collection(…)`) behaves identically everywhere, but raw `canopy.db.sql()` speaks your site's dialect — SQLite or Postgres (see [dialect()](https://docs.canopy.website/guides/data)). The sandbox defaults to Postgres. If your project uses raw SQL written for a SQLite site, lock the dialect in `canopy.json`:
 

package/dist/docs/platform-google.md

@@ -210,6 +210,14 @@ 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()`.
 
+## Daily limit
+
+Each project can make 10,000 Google calls a day. Calls Google turns down count
+too. Once a project reaches its limit, further calls fail until the count starts
+over at midnight UTC. The **Usage** tab shows today's count, the limit, and when
+it resets. If your project needs more, ask the Canopy team; they can raise the
+limit for your project.
+
 ## Local development
 
 `canopy dev` uses the real connections, so Google works the same on your

package/dist/docs/sdk-database.md

@@ -141,6 +141,9 @@ the dashboard (or `canopy db access` from the terminal):
   `collection("private_notes")` get a 403. Raw SQL cannot be checked table by
   table, so while your database holds any `private_` name, `db.sql()` from a
   page is refused too; use collections there, or run the SQL in the worker.
+  `canopy dev --local` applies the same rule, so you can test it on your
+  laptop. Plain `canopy dev` doesn't: your browser shares the dev server's
+  token there.
 
 Everyone who opens the app gets the same rule — colleagues signed in with
 OneLogin and, if you turned on [client access](https://docs.canopy.website/platform/client-access),

package/dist/{docs-Cdoh5sMW.mjs → docs-Bb9hSk4h.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-Doigafvd.mjs";
+import { t as version } from "./package-lYhex2Gp.mjs";
 import { n as siteConfig } from "./site-DM2J10CB.mjs";
 import { i as latestKnownVersion, r as compareSemver } from "./version-check-CcsA1QjI.mjs";
 import { r as reportErrors } from "./ui-C_jSc1Kz.mjs";

package/dist/{feedback-vvysW6iw.mjs → feedback-DzEKQlP6.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-Doigafvd.mjs";
+import { t as version } from "./package-lYhex2Gp.mjs";
 import { a as projectDirArgs, c as resolveProject, d as tryResolveProject, n as siteConfig, u as tryReadCanopyJson } from "./site-DM2J10CB.mjs";
 import { a as apiUpload, i as apiRequest, r as apiDownload } from "./api-C4rMhE7i.mjs";
 import { r as reportErrors, t as formatDateTime } from "./ui-C_jSc1Kz.mjs";

package/dist/index.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as version } from "./package-Doigafvd.mjs";
+import { t as version } from "./package-lYhex2Gp.mjs";
 import { r as siteHeaderLine, t as setInvocationProfile } from "./site-DM2J10CB.mjs";
 import { a as notifyOfUpdate, o as runRefresh } from "./version-check-CcsA1QjI.mjs";
 import { defineCommand, runMain } from "citty";
@@ -70,7 +70,7 @@ const main = defineCommand({
 		init: () => import("./projects-DQAhCZm8.mjs").then((m) => m.initCommand),
 		projects: () => import("./projects-DQAhCZm8.mjs").then((m) => m.projectsCommand),
 		delete: () => import("./projects-DQAhCZm8.mjs").then((m) => m.deleteCommand),
-		dev: () => import("./dev-DO6Eso4L.mjs").then((m) => m.devCommand),
+		dev: () => import("./dev-BeFX_wc5.mjs").then((m) => m.devCommand),
 		deploy: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.deployCommand),
 		promote: () => import("./deploy-Ka2lHkyy.mjs").then((m) => m.promoteCommand),
 		staging: () => import("./staging-BZVty57b.mjs").then((m) => m.stagingCommand),
@@ -80,17 +80,17 @@ const main = defineCommand({
 		egress: () => import("./egress-If_Gsx_M.mjs").then((m) => m.egressCommand),
 		secrets: () => import("./secrets-BSEjZnxg.mjs").then((m) => m.secretsCommand),
 		schedule: () => import("./schedule-C5lMf3ny.mjs").then((m) => m.scheduleCommand),
-		feedback: () => import("./feedback-vvysW6iw.mjs").then((m) => m.feedbackCommand),
+		feedback: () => import("./feedback-DzEKQlP6.mjs").then((m) => m.feedbackCommand),
 		db: () => import("./db-BB6O6085.mjs").then((m) => m.dbCommand),
 		usage: () => import("./usage-CUYrWxv0.mjs").then((m) => m.usageCommand),
 		ai: () => import("./ai-DHLnyqfq.mjs").then((m) => m.aiCommand),
 		open: () => import("./open-DcaQKi1v.mjs").then((m) => m.openCommand),
 		browse: () => import("./browse-Dycwj0V_.mjs").then((m) => m.browseCommand),
-		docs: () => import("./docs-Cdoh5sMW.mjs").then((m) => m.docsCommand),
-		skill: () => import("./skill-DfSAZ2cW.mjs").then((m) => m.skillCommand),
-		upgrade: () => import("./upgrade-DCQ3NzoL.mjs").then((m) => m.upgradeCommand),
+		docs: () => import("./docs-Bb9hSk4h.mjs").then((m) => m.docsCommand),
+		skill: () => import("./skill-BUA2uRR2.mjs").then((m) => m.skillCommand),
+		upgrade: () => import("./upgrade-ZSb56qBJ.mjs").then((m) => m.upgradeCommand),
 		logs: () => import("./logs-DQQOawOG.mjs").then((m) => m.logsCommand),
-		mcp: () => import("./mcp-OR_ashGC.mjs").then((m) => m.mcpCommand),
+		mcp: () => import("./mcp-pNp-sbfJ.mjs").then((m) => m.mcpCommand),
 		repo: () => import("./repo-1RQ1vBMv.mjs").then((m) => m.repoCommand)
 	}
 });

package/dist/{local-qR8CBseB.mjs → local-Cyl39_Zu.mjs}

@@ -1,10 +1,54 @@
 import { n as apiDataRequest } from "./api-C4rMhE7i.mjs";
-import { a as dbRouter, i as realtimeRouter, o as META_COLUMNS, s as blobRouter } from "./src-DE37PKho.mjs";
-import { i as rewriteApiPath } from "./dev-CGSIY1-y.mjs";
+import { a as realtimeRouter, c as META_COLUMNS, l as blobRouter, n as WORKER_ATTEST_HEADER, o as dbRouter, s as hasPrivateNames } from "./src-CxzGOEhP.mjs";
+import { a as rewriteApiPath } from "./dev-BdXslHoA.mjs";
 import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join, relative, sep } from "node:path";
 import { Hono } from "hono";
+//#region ../data-plane/src/db-access.ts
+/** The worker-only marker: `private_` at the start of a collection or table name. */
+const PRIVATE_PREFIX = "private_";
+const isPrivateName = (name) => name.startsWith(PRIVATE_PREFIX);
+const CHANGE_HINT = "Change it under Data in the dashboard, or move this call into the worker.";
+/** The policy matrix. Only meaningful for callers where isBrowserOnProject() is true. */
+function decideBrowserDbAccess(level, op) {
+	if (level === "off") return {
+		allow: false,
+		error: "browser_db_access",
+		detail: `Browser access to this project's database is off. ${CHANGE_HINT}`
+	};
+	if ((op.kind === "read" || op.kind === "write") && isPrivateName(op.collection)) return {
+		allow: false,
+		error: "private_collection",
+		detail: `"${op.collection}" is a private_ collection — only the project's worker can use it.`
+	};
+	if (op.kind === "sql") {
+		if (op.privateTables) return {
+			allow: false,
+			error: "private_tables_present",
+			detail: "This project has private_ tables or collections, so raw SQL is not available from the browser. Use collections here, or run the SQL in the worker."
+		};
+		if (level === "readonly") {
+			if (op.readonly === false) return {
+				allow: false,
+				error: "browser_db_access",
+				detail: `Browser access to this project's database is read-only. ${CHANGE_HINT}`
+			};
+			return {
+				allow: true,
+				forceReadonly: true
+			};
+		}
+		return { allow: true };
+	}
+	if (op.kind === "write" && level === "readonly") return {
+		allow: false,
+		error: "browser_db_access",
+		detail: `Browser access to this project's database is read-only. ${CHANGE_HINT}`
+	};
+	return { allow: true };
+}
+//#endregion
 //#region ../data-plane/src/dialect-postgres.ts
 /**
 * Postgres doc-store dialect (Cloud SQL, PGlite). Same table shape as SQLite
@@ -778,6 +822,7 @@ async function createPgliteDb(persistDir) {
 			const tables = (await db.query(`SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename`)).rows;
 			for (const { tablename } of tables) await db.exec(`DROP TABLE IF EXISTS "${tablename.replaceAll("\"", "\"\"")}" CASCADE`);
 		},
+		withoutForeignKeys: (fn) => fn(),
 		close: () => db.close()
 	};
 }
@@ -811,6 +856,14 @@ async function createSqliteDb(persistDir) {
 			for (const name of listTables(`sql LIKE 'CREATE VIRTUAL TABLE%'`)) db.exec(`DROP TABLE IF EXISTS "${name.replaceAll("\"", "\"\"")}"`);
 			for (const name of listTables(`name NOT LIKE 'sqlite_%'`)) db.exec(`DROP TABLE IF EXISTS "${name.replaceAll("\"", "\"\"")}"`);
 		},
+		withoutForeignKeys: async (fn) => {
+			db.exec("PRAGMA foreign_keys = OFF");
+			try {
+				return await fn();
+			} finally {
+				db.exec("PRAGMA foreign_keys = ON");
+			}
+		},
 		close: async () => {
 			db.close();
 		}
@@ -827,10 +880,25 @@ async function createSandbox(options) {
 		const requested = c.req.header("x-canopy-project") ?? c.req.query("project");
 		return requested === void 0 || requested === options.slug ? null : c.json({ error: "project_not_found" }, 404);
 	};
-	app.route("/data/v1", dbRouter({ store: async (c) => ownProject(c) ?? {
-		store,
-		dialect
-	} }));
+	app.route("/data/v1", dbRouter({
+		store: async (c) => ownProject(c) ?? {
+			store,
+			dialect
+		},
+		guard: async (c, op, resolved) => {
+			const attest = c.req.header(WORKER_ATTEST_HEADER);
+			if (options.workerAttest && attest === options.workerAttest) return void 0;
+			const decision = decideBrowserDbAccess("full", op.kind === "sql" ? {
+				kind: "sql",
+				readonly: op.readonly,
+				privateTables: await hasPrivateNames(resolved.store, resolved.dialect.name, PRIVATE_PREFIX)
+			} : op);
+			return decision.allow ? void 0 : c.json({
+				error: decision.error,
+				detail: decision.detail
+			}, 403);
+		}
+	}));
 	app.route("/data/v1", blobRouter({
 		store: async (c) => ownProject(c) ?? {
 			slug: options.slug,
@@ -900,15 +968,17 @@ async function createSandbox(options) {
 		return app.fetch(new Request(`http://sandbox${pathname}${url.search}`, request));
 	}
 	async function applyDump(sql) {
-		await db.reset();
-		for (const statement of splitSqlStatements(sql)) {
-			if (/^(BEGIN|COMMIT|ROLLBACK|SET\s+search_path|PRAGMA)\b/i.test(statement)) continue;
-			try {
-				await db.exec(statement);
-			} catch (err) {
-				throw new Error(`Dump statement failed: ${err instanceof Error ? err.message : String(err)}\n  in: ${statement.slice(0, 120)}${statement.length > 120 ? "…" : ""}`);
+		await db.withoutForeignKeys(async () => {
+			await db.reset();
+			for (const statement of splitSqlStatements(sql)) {
+				if (/^(BEGIN|COMMIT|ROLLBACK|SET\s+search_path|PRAGMA)\b/i.test(statement)) continue;
+				try {
+					await db.exec(statement);
+				} catch (err) {
+					throw new Error(`Dump statement failed: ${err instanceof Error ? err.message : String(err)}\n  in: ${statement.slice(0, 120)}${statement.length > 120 ? "…" : ""}`);
+				}
 			}
-		}
+		});
 		await rebuildFtsIndex(store, dialect);
 	}
 	return {

package/dist/{mcp-OR_ashGC.mjs → mcp-pNp-sbfJ.mjs}

@@ -1,4 +1,4 @@
-import { t as version } from "./package-Doigafvd.mjs";
+import { t as version } from "./package-lYhex2Gp.mjs";
 import { d as tryResolveProject, l as stagingUrl, n as siteConfig, s as projectUrl } from "./site-DM2J10CB.mjs";
 import { i as apiRequest, t as ApiError } from "./api-C4rMhE7i.mjs";
 import { t as liveDevServer } from "./dev-server-file-Dk9pk4AR.mjs";

package/dist/{package-Doigafvd.mjs → package-lYhex2Gp.mjs}

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

package/dist/{skill-DfSAZ2cW.mjs → skill-BUA2uRR2.mjs}

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

package/dist/{src-DE37PKho.mjs → src-CxzGOEhP.mjs}

@@ -292,6 +292,21 @@ async function introspectSchema(store, dialect) {
 		tables
 	};
 }
+/**
+* Does the database hold any table or doc collection whose name starts with
+* `prefix`? Two cheap probes — the browser-SQL guard (canopy-api, docs/35)
+* asks this on every page-originated raw-SQL call, so it must not walk the
+* schema. `prefix` is interpolated as a LIKE pattern; callers pass a fixed
+* identifier fragment (`private_`), never user input.
+*/
+async function hasPrivateNames(store, dialect, prefix) {
+	const pattern = lit(`${prefix.replaceAll("_", "\\_")}%`);
+	const [table, collection] = await Promise.all([store.query(dialect === "postgres" ? `SELECT 1 AS found FROM information_schema.tables
+              WHERE table_schema = current_schema() AND table_type = 'BASE TABLE'
+                AND table_name LIKE ${pattern} ESCAPE '\\' LIMIT 1` : `SELECT 1 AS found FROM sqlite_master
+              WHERE type = 'table' AND name LIKE ${pattern} ESCAPE '\\' LIMIT 1`).then((r) => r.results.length > 0), store.query(`SELECT 1 AS found FROM _canopy_docs WHERE collection LIKE ${pattern} ESCAPE '\\' LIMIT 1`).then((r) => r.results.length > 0).catch(() => false)]);
+	return table || collection;
+}
 //#endregion
 //#region ../data-plane/src/db.ts
 /**
@@ -844,6 +859,12 @@ const IDENTITY_STAMP_HEADERS = [
 	"x-canopy-user-name"
 ];
 /**
+* Header carrying the project's worker token as runtime-origin proof (docs/35).
+* The data plane verifies it to exempt the worker from browser DB access even
+* when the worker is acting as a visitor (forwarding their cookie).
+*/
+const WORKER_ATTEST_HEADER = "x-canopy-worker-attest";
+/**
 * Header the gateway attaches to a project tools call (`/__canopy/mcp`,
 * docs/49): the caller's agent token. A credential like the session cookie —
 * the host keeps it for `env.CANOPY.fetch` and redacts it from the bundle.
@@ -907,4 +928,4 @@ function stampWorkerHeaders(headers, ctx) {
 	return headers;
 }
 //#endregion
-export { dbRouter as a, realtimeRouter as i, redactCanopyCredentials as n, META_COLUMNS as o, stampWorkerHeaders as r, blobRouter as s, CALLER_HEADER as t };
+export { realtimeRouter as a, META_COLUMNS as c, stampWorkerHeaders as i, blobRouter as l, WORKER_ATTEST_HEADER as n, dbRouter as o, redactCanopyCredentials as r, hasPrivateNames as s, CALLER_HEADER as t };

package/dist/{upgrade-DCQ3NzoL.mjs → upgrade-ZSb56qBJ.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-DfSAZ2cW.mjs");
+		const { skillInstalled } = await import("./skill-BUA2uRR2.mjs");
 		const { homedir } = await import("node:os");
 		const refreshGlobal = skillInstalled(homedir());
 		const refreshRepo = process.cwd() !== homedir() && skillInstalled(process.cwd());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mediamonks/canopy-cli",
-  "version": "0.7.34",
+  "version": "0.7.36",
   "description": "Canopy CLI — create, develop and deploy Canopy projects.",
   "bin": {
     "canopy": "./dist/index.mjs"

package/dist/dev-DO6Eso4L.mjs

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