ninepm 0.36.0 → 0.39.0

package/README.md

@@ -86,10 +86,12 @@ Store and share working files:
 9pm files put ./report.pdf
 9pm files share <file-id> --expires 24h
 9pm files put ./notes.md --project my-app --path notes/release.md
-9pm files share <file-id> --project my-app --login-required
+9pm files share <file-id> --project my-app --public
 ```
 
-Personal files and project files both count toward the account file storage limit. Share links expire and are capped at 7 days. Login-required links are owner-only.
+Personal files and project files both count toward the account file storage limit. Share links expire and are capped at 7 days.
+
+Share links are **owner-only by default**: the link opens only for you, signed in. Add `--public` when the recipient has no account — that link needs no sign-in, so anyone who obtains the URL can download the file until it expires. Do not use `--public` for anything containing personal data, credentials or a database export.
 
 Deploy a first-class Worker runtime app:
 
@@ -186,7 +188,7 @@ Service token secrets returned by `access service create` are also server-side s
 9pm files list [--project <site>]
 9pm files put <local-path> [--path <remote-path>] [--project <site>]
 9pm files get <file-id> [--output <path>] [--project <site>]
-9pm files share <file-id> [--expires 24h] [--login-required] [--project <site>]
+9pm files share <file-id> [--expires 24h] [--public] [--project <site>]
 9pm files delete <file-id> [--project <site>]
 9pm deploy [directory] --runtime worker --entry <path> [--with-db]
 9pm delete <site> --confirm <slug>
@@ -223,8 +225,8 @@ Options:
 - `--project <site>` scopes file commands to an app
 - `--path <remote-path>` stores a file at a specific path
 - `--output <path>` writes a downloaded file to disk
-- `--expires <duration>` sets public share-link expiry, capped at 7 days
-- `--login-required` creates an owner-only share link
+- `--expires <duration>` sets share-link expiry, capped at 7 days
+- `--public` makes a share link downloadable by anyone with the URL, no sign-in (share links are owner-only without it)
 - `--confirm <slug>` confirms app deletion by requiring the slug
 - `--provider <google|github|entra>` selects a configured identity provider
 - `--duration <duration>` sets a service token duration

package/dist/deploy-limits.d.ts

@@ -1,7 +1,17 @@
 export declare const MAX_STATIC_ASSET_FILE_BYTES: number;
 export declare function formatMebibytes(bytes: number): string;
+export declare function formatMegabytes(bytes: number): string;
+export declare function formatKilobytes(bytes: number): string;
 export declare function assetFileTooLargeMessage(filePath: string, size: number): string;
 export declare function oversizedAssets<T extends {
     path: string;
     size: number;
 }>(files: readonly T[]): T[];
+export declare const MAX_WORKER_SCRIPT_COMPRESSED_BYTES: number;
+export declare const WORKER_WRAPPER_COMPRESSED_RESERVE_BYTES = 100000;
+export declare const MAX_WORKER_ENTRY_COMPRESSED_BYTES: number;
+export declare const WORKER_ENTRY_COMPRESSED_WARN_BYTES: number;
+export declare function workerEntryTooLargeMessage(filePath: string, rawBytes: number, compressedBytes: number): string;
+export declare function workerEntryNearLimitMessage(filePath: string, rawBytes: number, compressedBytes: number): string;
+export declare function workerBundleTooLargeMessage(moduleCount: number, rawBytes: number, compressedBytes: number): string;
+export declare function workerBundleNearLimitMessage(moduleCount: number, rawBytes: number, compressedBytes: number): string;

package/dist/deploy-limits.js

@@ -20,6 +20,18 @@ export function formatMebibytes(bytes) {
     // Whole numbers read cleanly (25 MiB); fractional sizes get one decimal.
     return Number.isInteger(mib) ? `${mib} MiB` : `${mib.toFixed(1)} MiB`;
 }
+// Decimal formatters for the worker script/entry budget. That limit is documented
+// in decimal MB (below), so rendering it in MiB would both misstate the unit and —
+// at 10 MB vs 9.5 MiB — print two different-looking numbers for the same ceiling.
+export function formatMegabytes(bytes) {
+    const mb = Math.max(0, bytes) / 1_000_000;
+    return Number.isInteger(mb) ? `${mb} MB` : `${mb.toFixed(1)} MB`;
+}
+// Sub-megabyte figures (the wrapper reserve) would render as a misleading "0.1 MB".
+export function formatKilobytes(bytes) {
+    const kb = Math.max(0, bytes) / 1000;
+    return Number.isInteger(kb) ? `${kb} kB` : `${kb.toFixed(1)} kB`;
+}
 export function assetFileTooLargeMessage(filePath, size) {
     return `File "${filePath}" is ${formatMebibytes(size)}; individual files are limited to ${formatMebibytes(MAX_STATIC_ASSET_FILE_BYTES)}.`;
 }
@@ -28,3 +40,81 @@ export function assetFileTooLargeMessage(filePath, size) {
 export function oversizedAssets(files) {
     return files.filter((file) => file.size > MAX_STATIC_ASSET_FILE_BYTES);
 }
+// The worker-runtime server entry is the one deploy-directory file inlined into
+// the generated Worker script (`buildHostedAppWorker`), so it — unlike every
+// other file, which rides the Workers Assets API — counts against the runtime's
+// script-size budget. That budget is enforced on the *compressed* upload, so
+// this limit is measured on gzipped bytes, not raw ones. Measuring raw bytes is
+// what made `deploy --check` reject bundles the real deploy path published
+// happily (#645): a 2.4 MB entry of inlined SVG/base64 compresses to well under
+// a megabyte, and the platform only ever saw the compressed figure.
+// The runtime's ceiling on the whole generated script, compressed. Documented as
+// "10 MB after compression" on the paid plan:
+// https://developers.cloudflare.com/workers/platform/limits/
+// Read as decimal (10,000,000), not 10 MiB. The doc's unit is ambiguous, so take the
+// smaller reading: a ceiling below the real one only rejects deploys slightly early,
+// while one above it lets an entry pass every local check and still fail the upload.
+// 10 MiB would sit 485,760 bytes high — far more than the wrapper reserve below could
+// absorb, which would defeat the point of having a reserve at all.
+export const MAX_WORKER_SCRIPT_COMPRESSED_BYTES = 10 * 1_000_000;
+// What the app's own code does *not* get to spend: whichever wrapper the platform
+// generates is uploaded as part of the same script. Two consumers spend this reserve,
+// depending on the deploy shape:
+//   - single `--entry` workers: `buildHostedAppWorker` (analytics, end-user auth,
+//     Access/vanity-host checks, asset fallback), inlined around the entry;
+//   - `--bundle` deploys: `buildBundleWrapperModule`, added as the script's main module
+//     alongside the bundle's own modules.
+// Both were measured, and both are near-flat across feature combinations: the hosted
+// wrapper is ~36 KB raw / ~12 KB gzipped, the bundle wrapper ~23 KB raw / ~8 KB gzipped.
+// 100 kB is therefore a ~8x margin on the larger of the two, with room for growth in either.
+//
+// Without this reserve, code just under the ceiling passes both `--check` and the pre-create
+// deploy guard, then still blows the real upload once the wrapper is added — failing after
+// the project and slug have been created, which is the exact late failure the preflight
+// exists to prevent.
+export const WORKER_WRAPPER_COMPRESSED_RESERVE_BYTES = 100_000;
+// The budget actually available to the user's entry module.
+export const MAX_WORKER_ENTRY_COMPRESSED_BYTES = MAX_WORKER_SCRIPT_COMPRESSED_BYTES - WORKER_WRAPPER_COMPRESSED_RESERVE_BYTES;
+// Warn once the entry is within 20% of its budget.
+export const WORKER_ENTRY_COMPRESSED_WARN_BYTES = Math.floor(MAX_WORKER_ENTRY_COMPRESSED_BYTES * 0.8);
+// Exact bytes lead, with the rounded figure in parentheses for readability. Rounding
+// alone is not enough at the boundary: a size just over the cap renders identically to
+// the cap at one decimal, so the message read "is 9.9 MB compressed ... limited to
+// 9.9 MB compressed" for anything in 9,900,001..~9,950,000. That is the same
+// two-numbers-you-cannot-reconcile confusion this message exists to remove, and the
+// boundary is exactly where a rejected user lands. Fixed locale so the grouping is
+// stable regardless of the machine's default.
+function exactWithRounded(bytes) {
+    return `${bytes.toLocaleString("en-US")} bytes (${formatMegabytes(bytes)})`;
+}
+// Both messages name the measured dimension explicitly. The previous wording
+// ("is 2487048 bytes; limit is 1000000 bytes") gave no way to tell that the two
+// numbers described different things — raw against a compressed-derived cap.
+export function workerEntryTooLargeMessage(filePath, rawBytes, compressedBytes) {
+    return (`Worker runtime entry "${filePath}" is ${exactWithRounded(compressedBytes)} compressed, ` +
+        `${exactWithRounded(rawBytes)} raw; the entry is limited to ${exactWithRounded(MAX_WORKER_ENTRY_COMPRESSED_BYTES)} compressed ` +
+        `(the ${formatMegabytes(MAX_WORKER_SCRIPT_COMPRESSED_BYTES)} script limit, less ${formatKilobytes(WORKER_WRAPPER_COMPRESSED_RESERVE_BYTES)} reserved for the generated wrapper). ` +
+        `Move large static assets out of the entry into sibling files in the deploy directory — they are served ` +
+        `from the asset store and do not count toward this limit — or deploy as a container.`);
+}
+export function workerEntryNearLimitMessage(filePath, rawBytes, compressedBytes) {
+    return (`Worker runtime entry "${filePath}" is ${exactWithRounded(compressedBytes)} compressed, ` +
+        `${exactWithRounded(rawBytes)} raw — over 80% of the ${exactWithRounded(MAX_WORKER_ENTRY_COMPRESSED_BYTES)} compressed entry limit.`);
+}
+// Framework-bundle equivalents (#660). A bundle's modules are uploaded as one script,
+// so the same budget applies to their combined compressed size rather than to any single
+// file — worth saying explicitly, because the per-file asset cap is a different limit and
+// conflating the two is what put a wrong figure in the hosted skill in the first place.
+// The remedy differs too: a bundle's assets already live outside the modules, so the
+// actionable advice is about the server build, not about un-inlining assets.
+export function workerBundleTooLargeMessage(moduleCount, rawBytes, compressedBytes) {
+    return (`Worker bundle's ${moduleCount} server module${moduleCount === 1 ? "" : "s"} total ${exactWithRounded(compressedBytes)} compressed, ` +
+        `${exactWithRounded(rawBytes)} raw; server code is limited to ${exactWithRounded(MAX_WORKER_ENTRY_COMPRESSED_BYTES)} compressed ` +
+        `(the ${formatMegabytes(MAX_WORKER_SCRIPT_COMPRESSED_BYTES)} script limit, less ${formatKilobytes(WORKER_WRAPPER_COMPRESSED_RESERVE_BYTES)} reserved for the generated wrapper). ` +
+        `Files under the bundle's assets directory are served from the asset store and do not count toward this limit, ` +
+        `so move what you can there; otherwise trim the server build or deploy as a container.`);
+}
+export function workerBundleNearLimitMessage(moduleCount, rawBytes, compressedBytes) {
+    return (`Worker bundle's ${moduleCount} server module${moduleCount === 1 ? "" : "s"} total ${exactWithRounded(compressedBytes)} compressed, ` +
+        `${exactWithRounded(rawBytes)} raw — over 80% of the ${exactWithRounded(MAX_WORKER_ENTRY_COMPRESSED_BYTES)} compressed server-code limit.`);
+}

package/dist/index.d.ts

@@ -113,7 +113,7 @@ export interface CreatedServiceToken {
     clientSecret: string;
 }
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-export declare const CLI_VERSION = "0.36.0";
+export declare const CLI_VERSION = "0.39.0";
 type CredentialBackend = "macos-keychain" | "windows-dpapi" | "linux-secret-service" | "file-plaintext" | "none";
 export interface CredentialDiagnostics {
     platform: NodeJS.Platform;
@@ -173,6 +173,11 @@ export interface DeployCheckResult {
     errors: string[];
     files: number;
     bytes: number;
+    serverCode?: {
+        rawBytes: number;
+        compressedBytes: number;
+        moduleCount: number;
+    };
 }
 export type DetectedFramework = "nextjs" | "astro" | "sveltekit" | "vite";
 export declare function detectFramework(directory: string): DetectedFramework | null;
@@ -187,6 +192,14 @@ export declare function deployDirectory(initialOptions: DeployOptions): Promise<
 export type ApiReachability = "reachable" | "blocked";
 export declare function probeApiReachability(apiUrl: string, fetchFn: typeof fetch, timeoutMs?: number): Promise<ApiReachability>;
 export declare function apiUnreachableGuidance(apiUrl: string): string;
+export declare function measureWorkerEntry(source: Uint8Array): {
+    rawBytes: number;
+    compressedBytes: number;
+};
+export declare function measureWorkerModuleFiles(root: string, modulePaths: readonly string[]): Promise<{
+    rawBytes: number;
+    compressedBytes: number;
+}>;
 export declare function checkDeployDirectory(options: DeployOptions): Promise<DeployCheckResult>;
 export declare function whoami(options: ApiOptions): Promise<WhoamiResult>;
 export declare function publicWhoamiResult(result: WhoamiResult): PublicWhoamiResult;

package/dist/index.js

@@ -7,12 +7,14 @@ import os from "node:os";
 import path from "node:path";
 import { chmodSync, cpSync, existsSync, mkdirSync, mkdtempSync, openAsBlob, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { fileURLToPath } from "node:url";
+import { once } from "node:events";
+import { createGzip, gzipSync } from "node:zlib";
 import { Agent, fetch as undiciFetch } from "undici";
 import { MAX_DEPLOY_DESCRIPTION_LENGTH, normalizeDeployDescription } from "./deploy-description.js";
-import { assetFileTooLargeMessage, oversizedAssets } from "./deploy-limits.js";
+import { MAX_STATIC_ASSET_FILE_BYTES, MAX_WORKER_ENTRY_COMPRESSED_BYTES, MAX_WORKER_SCRIPT_COMPRESSED_BYTES, WORKER_ENTRY_COMPRESSED_WARN_BYTES, assetFileTooLargeMessage, formatMebibytes, formatMegabytes, oversizedAssets, workerBundleNearLimitMessage, workerBundleTooLargeMessage, workerEntryNearLimitMessage, workerEntryTooLargeMessage, } from "./deploy-limits.js";
 import { buildFileManifest, readManifestFile } from "./manifest.js";
 import { API_KEY_HELP, API_URL_HELP, CLI_CLIENT_ID, DEFAULT_API_URL, reportCliError } from "./cli-config.js";
-export const CLI_VERSION = "0.36.0";
+export const CLI_VERSION = "0.39.0";
 const PUBLIC_DASHBOARD_URL = "https://9pm.ai/dashboard";
 const TOKEN_SERVICE = "9pm";
 const TOKEN_ACCOUNT = "default";
@@ -21,8 +23,6 @@ const WINDOWS_CREDENTIAL_FILE = "credential.dpapi";
 const PLAINTEXT_CREDENTIAL_FILE = "credential.plaintext.json";
 const ALLOW_FILE_CREDENTIAL_STORE_ENV = "NINEPM_ALLOW_FILE_CREDENTIAL_STORE";
 const DISABLE_NATIVE_CREDENTIAL_STORE_ENV = "NINEPM_DISABLE_NATIVE_CREDENTIAL_STORE";
-const WORKER_ENTRY_LIMIT_BYTES = 1_000_000;
-const WORKER_ENTRY_WARN_BYTES = Math.floor(WORKER_ENTRY_LIMIT_BYTES * 0.8);
 const DEFAULT_CONTAINER_POLL_TIMEOUT_MS = 15 * 60 * 1000;
 export function detectFramework(directory) {
     let dependencies = {};
@@ -273,7 +273,11 @@ async function runDeploy(initialOptions, slugHolder) {
     // across every deploy call — create, upload, finalize, poll — with one wrap.
     const fetchFn = withFetchDiagnostics(options.fetchFn ?? fetch);
     const apiUrl = normalizeApiUrl(options.apiUrl);
-    const runtime = options.runtime ?? (options.entry ? "worker" : "static");
+    // A bundle is a worker deploy. Parsing `--bundle` already forces runtime to "worker", so
+    // this is a no-op for every CLI invocation; it matters for programmatic callers that pass
+    // bundleDir alone, which would otherwise record the deployment as static here while
+    // checkDeployDirectory classified the same input as a worker (#661 self-review).
+    const runtime = options.runtime ?? (options.entry || options.bundleDir ? "worker" : "static");
     if (!options.runtime && runtime === "static" && hasDockerfile(options.directory)) {
         throw new Error(DOCKERFILE_STATIC_HINT);
     }
@@ -403,6 +407,8 @@ async function runDeploy(initialOptions, slugHolder) {
     }
     const bundle = options.bundleDir ? bundleMetadataFromManifest(manifest, contentRoot) : null;
     const serverEntry = runtime === "worker" && !bundle ? normalizeServerEntry(options.entry ?? "src/index.js") : undefined;
+    // Set by the size preflight below and reused by the upload loop, so the entry is read once.
+    let serverEntryBytes;
     if (serverEntry && !manifest.some((file) => file.path === serverEntry)) {
         throw new Error(`Worker runtime entry file was not found in the deploy directory: ${serverEntry}`);
     }
@@ -413,6 +419,39 @@ async function runDeploy(initialOptions, slugHolder) {
     if (oversized) {
         throw new Error(assetFileTooLargeMessage(oversized.path, oversized.size));
     }
+    // Same worker-entry budget `--check` applies, on the same compressed dimension, so
+    // the two paths agree (#645). This rejects only what the runtime would refuse at
+    // publish time anyway — it turns an opaque late failure into a local one, before
+    // the project is created and the slug claimed.
+    if (serverEntry) {
+        // Held for the upload below: re-reading the entry there would read a file of up to
+        // 25 MiB twice on every worker deploy.
+        serverEntryBytes = await readManifestFile(contentRoot, serverEntry);
+        const { rawBytes, compressedBytes } = measureWorkerEntry(serverEntryBytes);
+        if (compressedBytes > MAX_WORKER_ENTRY_COMPRESSED_BYTES) {
+            throw new Error(workerEntryTooLargeMessage(serverEntry, rawBytes, compressedBytes));
+        }
+        if (compressedBytes >= WORKER_ENTRY_COMPRESSED_WARN_BYTES) {
+            // Same band, same wording, same channel as `--check` (see the CLI entry point), so a
+            // near-limit entry doesn't deploy silently and then get rejected on a slightly
+            // larger build with no prior notice.
+            console.warn(`Warning: ${workerEntryNearLimitMessage(serverEntry, rawBytes, compressedBytes)}`);
+        }
+    }
+    // Bundles carry the same budget, applied to all their server modules together (#660).
+    // Without this the `--bundle` path — the one the hosted skill's size guidance is about —
+    // was the only worker shape with no local size check at all, so an over-budget framework
+    // build failed at publish instead, after the project and slug existed.
+    if (bundle) {
+        const modulePaths = bundleModulePaths(bundle);
+        const { rawBytes, compressedBytes } = await measureWorkerModuleFiles(contentRoot, modulePaths);
+        if (compressedBytes > MAX_WORKER_ENTRY_COMPRESSED_BYTES) {
+            throw new Error(workerBundleTooLargeMessage(modulePaths.length, rawBytes, compressedBytes));
+        }
+        if (compressedBytes >= WORKER_ENTRY_COMPRESSED_WARN_BYTES) {
+            console.warn(`Warning: ${workerBundleNearLimitMessage(modulePaths.length, rawBytes, compressedBytes)}`);
+        }
+    }
     const projectInput = { name: options.name ?? path.basename(path.resolve(options.directory)) };
     const { project, created: projectCreated } = await createProject(fetchFn, apiUrl, options.token, options.slug ? { ...projectInput, slug: options.slug } : projectInput);
     slugHolder.slug = project.slug;
@@ -448,7 +487,9 @@ async function runDeploy(initialOptions, slugHolder) {
     for (const upload of created.uploads) {
         const file = manifest.find((candidate) => candidate.path === upload.path.split("/").slice(4).map(decodeURIComponent).join("/"));
         const manifestPath = file?.path ?? pathFromUpload(upload, created.deployment.id);
-        const body = await readManifestFile(contentRoot, manifestPath);
+        // The worker entry was already read for the size preflight above; reuse those bytes
+        // rather than reading a file of up to 25 MiB a second time.
+        const body = manifestPath === serverEntry && serverEntryBytes ? serverEntryBytes : await readManifestFile(contentRoot, manifestPath);
         const response = await fetchFn(upload.uploadUrl, {
             method: upload.method,
             headers: {
@@ -469,8 +510,76 @@ async function runDeploy(initialOptions, slugHolder) {
         url: finalized.url,
     };
 }
+// Measure the worker-runtime entry the way the platform's script-size budget is
+// actually applied: the entry is inlined into the generated Worker script, and the
+// budget is enforced against the compressed upload. gzipped bytes are therefore
+// the comparable figure; the raw size is carried alongside for the error message
+// only, so a report can name both dimensions instead of silently mixing them.
+//
+// Deliberately zlib's default level rather than 9: the platform's own compression
+// settings are unknown, and a weaker setting yields a slightly *larger* figure, so
+// the guard errs toward rejecting early rather than passing an entry the real upload
+// would refuse. It is also markedly cheaper on a large entry, and this now runs on
+// every worker deploy, not just `--check`.
+export function measureWorkerEntry(source) {
+    return { rawBytes: source.byteLength, compressedBytes: gzipSync(source).byteLength };
+}
+// A framework bundle's modules all ride one script upload, so the budget applies to their
+// combined compressed size (#660) — one gzip pass over the concatenation, not the sum of
+// each module's own gzip: separate streams share no dictionary, and on a many-module bundle
+// (OpenNext emits hundreds) summing overstates the total enough to reject a bundle the
+// platform would accept, which is the over-strict failure #645 was about.
+//
+// Streamed rather than concatenated in memory. Only the compressed *length* is needed, so
+// output chunks are counted and dropped, and modules are read one at a time: peak memory is
+// one module plus gzip's window regardless of bundle size. Buffering every module and then
+// copying them into one combined buffer peaked above twice the raw bundle and could be
+// OOM-killed before it managed to report the size error it existed to report.
+//
+// It deliberately does not stop early once the limit is passed. The messages report exact
+// byte counts — that precision is what keeps them unambiguous at the boundary — and a floor
+// like "at least N bytes" would give that up to save a second on an already-failing deploy.
+export async function measureWorkerModuleFiles(root, modulePaths) {
+    const gzip = createGzip();
+    let rawBytes = 0;
+    let compressedBytes = 0;
+    // Attaching a data listener puts the stream in flowing mode, so "end" arrives once the
+    // whole compressed output has been counted.
+    gzip.on("data", (chunk) => {
+        compressedBytes += chunk.byteLength;
+    });
+    const finished = new Promise((resolve, reject) => {
+        gzip.once("end", () => resolve());
+        gzip.once("error", reject);
+    });
+    // A read failing mid-bundle leaves the loop without awaiting `finished`. Register a
+    // handler now so that path cannot surface as an unhandled rejection; `await finished`
+    // below still observes a real error, since a promise may carry several handlers.
+    finished.catch(() => { });
+    try {
+        for (const modulePath of modulePaths) {
+            const bytes = await readManifestFile(root, modulePath);
+            rawBytes += bytes.byteLength;
+            if (!gzip.write(bytes)) {
+                // Respect backpressure so a large bundle cannot balloon the stream's internal queue.
+                await once(gzip, "drain");
+            }
+        }
+        gzip.end();
+        await finished;
+    }
+    catch (error) {
+        // Don't leave a half-written stream alive when a module can't be read.
+        gzip.destroy();
+        throw error;
+    }
+    return { rawBytes, compressedBytes };
+}
 export async function checkDeployDirectory(options) {
-    const runtime = options.runtime ?? (options.entry ? "worker" : "static");
+    // `--bundle` implies the worker runtime, matching runDeploy's derivation exactly. Without
+    // this a bundle check fell through to "static" and silently graded a framework bundle as
+    // a static site: no server-code check, and a spurious missing-index.html warning (#660).
+    const runtime = options.runtime ?? (options.entry || options.bundleDir ? "worker" : "static");
     if (runtime === "container") {
         const warnings = [];
         const errors = [];
@@ -486,11 +595,42 @@ export async function checkDeployDirectory(options) {
         }
         return { ok: errors.length === 0, warnings, errors, files: 0, bytes: 0 };
     }
-    const manifest = await buildFileManifest(options.directory);
-    const serverEntry = runtime === "worker" ? normalizeServerEntry(options.entry ?? "src/index.js") : undefined;
+    // Mirror runDeploy: a bundle deploy reads from `--bundle <dir>` rather than the project
+    // root, and drops source maps. Checking the wrong directory is how `--check` and `deploy`
+    // drift apart, which is the whole failure mode this guard exists to prevent.
+    const contentRoot = options.bundleDir ? path.resolve(options.directory, options.bundleDir) : options.directory;
+    if (options.bundleDir) {
+        // `--check` reports problems rather than throwing them. Before this path knew about
+        // bundles it never touched the bundle directory, so a wrong `--bundle` argument now
+        // reaches the manifest walk and would otherwise surface as a raw ENOENT, not a finding.
+        const stats = statSync(contentRoot, { throwIfNoEntry: false });
+        if (!stats?.isDirectory()) {
+            return { ok: false, warnings: [], errors: [`Bundle directory was not found: ${contentRoot}`], files: 0, bytes: 0 };
+        }
+    }
+    let manifest = await buildFileManifest(contentRoot);
+    if (options.bundleDir) {
+        manifest = manifest.filter((file) => !file.path.endsWith(".map"));
+    }
     const totalBytes = manifest.reduce((sum, file) => sum + file.size, 0);
     const warnings = [];
     const errors = [];
+    // Reported even when the check passes, so `--check` actually prints the compressed figure
+    // the hosted skill tells agents to read (#661 review). Warnings only fire in the top 20%
+    // of the budget, so without this a healthy bundle produced no size information at all.
+    let serverCode;
+    // bundleMetadataFromManifest throws when the layout is wrong; `--check` reports that as a
+    // finding rather than an exception, since reporting problems is its entire job.
+    let bundle = null;
+    if (options.bundleDir) {
+        try {
+            bundle = bundleMetadataFromManifest(manifest, contentRoot);
+        }
+        catch (error) {
+            errors.push(error instanceof Error ? error.message : String(error));
+        }
+    }
+    const serverEntry = runtime === "worker" && !options.bundleDir ? normalizeServerEntry(options.entry ?? "src/index.js") : undefined;
     if (manifest.length === 0) {
         errors.push("Directory contains no deployable files.");
     }
@@ -511,19 +651,35 @@ export async function checkDeployDirectory(options) {
             errors.push(`Worker runtime entry file was not found: ${serverEntry}`);
         }
         else {
-            if (entry.size > WORKER_ENTRY_LIMIT_BYTES) {
-                errors.push(`Worker runtime entry is ${entry.size} bytes; limit is ${WORKER_ENTRY_LIMIT_BYTES} bytes.`);
+            const bytes = await readManifestFile(contentRoot, serverEntry);
+            const { rawBytes, compressedBytes } = measureWorkerEntry(bytes);
+            serverCode = { rawBytes, compressedBytes, moduleCount: 1 };
+            if (compressedBytes > MAX_WORKER_ENTRY_COMPRESSED_BYTES) {
+                errors.push(workerEntryTooLargeMessage(serverEntry, rawBytes, compressedBytes));
             }
-            else if (entry.size >= WORKER_ENTRY_WARN_BYTES) {
-                warnings.push(`Worker runtime entry is over 80% of the ${WORKER_ENTRY_LIMIT_BYTES} byte limit.`);
+            else if (compressedBytes >= WORKER_ENTRY_COMPRESSED_WARN_BYTES) {
+                warnings.push(workerEntryNearLimitMessage(serverEntry, rawBytes, compressedBytes));
             }
-            const source = new TextDecoder().decode(await readManifestFile(options.directory, serverEntry));
-            const bundle = await validateWorkerEntrySource(source, serverEntry);
-            warnings.push(...bundle.warnings);
-            errors.push(...bundle.errors);
+            const source = new TextDecoder().decode(bytes);
+            const entrySource = await validateWorkerEntrySource(source, serverEntry);
+            warnings.push(...entrySource.warnings);
+            errors.push(...entrySource.errors);
         }
     }
-    return { ok: errors.length === 0, warnings, errors, files: manifest.length, bytes: totalBytes };
+    // Same server-code budget the real deploy applies to a bundle (#660), measured the same
+    // way — all modules compressed together, assets excluded.
+    if (bundle) {
+        const modulePaths = bundleModulePaths(bundle);
+        const { rawBytes, compressedBytes } = await measureWorkerModuleFiles(contentRoot, modulePaths);
+        serverCode = { rawBytes, compressedBytes, moduleCount: modulePaths.length };
+        if (compressedBytes > MAX_WORKER_ENTRY_COMPRESSED_BYTES) {
+            errors.push(workerBundleTooLargeMessage(modulePaths.length, rawBytes, compressedBytes));
+        }
+        else if (compressedBytes >= WORKER_ENTRY_COMPRESSED_WARN_BYTES) {
+            warnings.push(workerBundleNearLimitMessage(modulePaths.length, rawBytes, compressedBytes));
+        }
+    }
+    return { ok: errors.length === 0, warnings, errors, files: manifest.length, bytes: totalBytes, ...(serverCode ? { serverCode } : {}) };
 }
 export async function whoami(options) {
     return apiRequest(options, "/v1/me", { method: "GET" });
@@ -1841,7 +1997,22 @@ function parseFilesArgs(argv) {
             throw new Error("Missing file id.");
         }
         const expires = readStringFlag(flags, "expires") ?? "24h";
-        const mode = flags.has("login-required") ? "login_required" : "public";
+        // Publishing to the open internet is opt-IN: a public share needs no sign-in,
+        // so the bare form must not produce one. `--login-required` is still accepted
+        // (it is now the default) so existing callers keep working. Both flags together
+        // is ambiguous on a control that decides public exposure, so it fails rather
+        // than applying a precedence rule the caller cannot see. See #637.
+        if (flags.has("public") && flags.has("login-required")) {
+            throw new Error("Pass either --public or --login-required, not both.");
+        }
+        // parseFlags stores the next non-`--` token as a flag's value, so `--public false`
+        // sets "false" and `flags.has` is still true — the value reads as a disable and
+        // publishes anyway. Only guarded on this flag: a misread `--login-required <value>`
+        // still resolves to owner-only, which is safe, whereas this one exposes a file.
+        if (typeof flags.get("public") === "string") {
+            throw new Error("--public takes no value. Omit it for an owner-only link.");
+        }
+        const mode = flags.has("public") ? "public" : "login_required";
         return { kind: "files", ...base, action: { kind: "share", fileId, mode, expiresInSeconds: parseDurationSeconds(expires), ...withProject } };
     }
     throw new Error(`Unknown files command: ${subcommand}`);
@@ -2293,6 +2464,13 @@ function bundleMetadataFromManifest(manifest, contentRoot) {
         compatibilityFlags: ["nodejs_compat"],
     };
 }
+// bundleMetadataFromManifest returns the shape the API stores verbatim
+// (Record<string, unknown>), so narrow the module list here rather than loosening
+// that contract just to read it back.
+function bundleModulePaths(bundle) {
+    const modules = bundle.modules;
+    return Array.isArray(modules) ? modules.filter((entry) => typeof entry === "string") : [];
+}
 function parseMemorySize(value) {
     const match = value.trim().toLowerCase().match(/^(\d+)\s*(g|gb|m|mb)?$/);
     if (!match) {
@@ -2815,6 +2993,14 @@ async function main() {
                 }
                 else {
                     console.log(`Deploy check passed: ${check.files} file(s), ${check.bytes} byte(s).`);
+                    if (check.serverCode) {
+                        // The compressed server-code figure, printed on success as well as on
+                        // warning/rejection, so the number the size limit is enforced on is always
+                        // visible — the hosted skill tells agents to read it from here.
+                        const { compressedBytes, moduleCount } = check.serverCode;
+                        const subject = moduleCount === 1 ? "entry" : `${moduleCount} server modules`;
+                        console.log(`Server code (${subject}): ${compressedBytes.toLocaleString("en-US")} bytes compressed of ${MAX_WORKER_ENTRY_COMPRESSED_BYTES.toLocaleString("en-US")} allowed.`);
+                    }
                 }
                 return;
             }
@@ -3102,7 +3288,14 @@ async function runFilesCommand(command) {
             expiresInSeconds: command.action.expiresInSeconds,
         });
         console.log(result.url);
-        console.log(`Share mode: ${result.share.mode === "login_required" ? "owner-only" : "public"}, expires ${result.share.expiresAt}.`);
+        if (result.share.mode === "public") {
+            // Say it plainly at the moment it becomes true: an agent pasting this into a
+            // chat should not be the only place the word "public" appears (#637).
+            console.log(`Share mode: PUBLIC — anyone with this URL can download the file, no sign-in. Expires ${result.share.expiresAt}.`);
+        }
+        else {
+            console.log(`Share mode: owner-only — only you can open it, signed in. Expires ${result.share.expiresAt}.`);
+        }
     }
 }
 function printUsage() {
@@ -3126,7 +3319,7 @@ function printUsage() {
   9pm files list [--project <site>]
   9pm files put <local-path> [--path <remote-path>] [--project <site>]
   9pm files get <file-id> [--output <path>] [--project <site>]
-  9pm files share <file-id> [--expires 24h] [--login-required] [--project <site>]
+  9pm files share <file-id> [--expires 24h] [--public] [--project <site>]
   9pm files delete <file-id> [--project <site>]
   9pm deployments ls <app> [--json]
   9pm deployments rm <deployment-id>
@@ -3151,6 +3344,15 @@ Environment:
   ${ALLOW_FILE_CREDENTIAL_STORE_ENV}
                      Allow plaintext credential file fallback when native storage is unavailable
 
+Size limits:
+  Individual files are limited to ${formatMebibytes(MAX_STATIC_ASSET_FILE_BYTES)}.
+  Worker runtime: server code is limited to ${formatMegabytes(MAX_WORKER_ENTRY_COMPRESSED_BYTES)} compressed (gzip) — the ${formatMegabytes(MAX_WORKER_SCRIPT_COMPRESSED_BYTES)} script limit
+  less a small reserve for the generated wrapper. That budget covers the --entry module, or
+  with --bundle every server module together, since they deploy as one script. Every other
+  file in the directory is served from the asset store instead, so it does not count toward
+  that limit — keep large images, fonts and datasets as sibling files rather than inlining
+  them into the entry. Apps needing more server code than that should deploy as containers.
+
 Container deploys:
   Requires Docker locally. The CLI builds linux/amd64, exports the image, uploads it through a short-lived session, then finalizes a queued deployment.
   The app must listen on 0.0.0.0:$PORT or the selected --port. Use --health-path for a cheap readiness endpoint.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ninepm",
-  "version": "0.36.0",
+  "version": "0.39.0",
   "description": "CLI for deploying built apps to 9pm.ai.",
   "homepage": "https://9pm.ai",
   "keywords": [