ninepm 0.34.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.34.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;
@@ -244,12 +257,19 @@ export interface ListSitesResult {
 }
 export declare function listSites(options: ApiOptions): Promise<ListSitesResult>;
 export declare function deleteSite(options: DeleteSiteOptions): Promise<DeletedSiteResult>;
+export interface DeviceAuthFeedbackOptions {
+    progressStream?: NodeJS.WriteStream;
+    openBrowserFn?: (url: string) => BrowserOpenResult;
+    storeCredentialFn?: (token: string, options: {
+        allowFileFallback?: boolean | undefined;
+    }) => string;
+}
 export declare function loginDevice(options: {
     apiUrl: string;
     fetchFn?: FetchLike;
     machineName?: string;
     allowFileCredentialStore?: boolean;
-}): Promise<{
+} & DeviceAuthFeedbackOptions): Promise<{
     email?: string;
     storage: string;
 }>;
@@ -258,10 +278,11 @@ export declare function signupDevice(options: {
     fetchFn?: FetchLike;
     machineName?: string;
     allowFileCredentialStore?: boolean;
-}): Promise<{
+} & DeviceAuthFeedbackOptions): Promise<{
     email?: string;
     storage: string;
 }>;
+export declare function expiredDeviceAuthMessage(purpose: string, userCode: string, lifetimeMs: number, verificationUri: string): string;
 export declare function listManagedFiles(options: FileCommandOptions): Promise<ManagedFileListResult>;
 export declare function putManagedFile(options: FilePutOptions): Promise<ManagedFilePutResult>;
 export declare function getManagedFile(options: FileGetOptions): Promise<{
@@ -294,6 +315,11 @@ export interface UploadProgressReporter {
     stop(): void;
 }
 export declare function createUploadProgressReporter(stream?: NodeJS.WriteStream): UploadProgressReporter;
+export interface DeviceAuthProgressReporter {
+    tick(remainingMs: number): void;
+    stop(): void;
+}
+export declare function createDeviceAuthProgressReporter(stream?: NodeJS.WriteStream): DeviceAuthProgressReporter;
 type CliCommand = {
     kind: "deploy";
     options: DeployOptions;
@@ -466,6 +492,13 @@ export declare function parseEnvFileEntries(content: string, kind: "secret" | "v
     kind: "secret" | "var";
 }>;
 export declare function credentialDiagnostics(): CredentialDiagnostics;
+export type BrowserOpenResult = "opened" | "failed" | "unknown";
+export declare function classifyBrowserOpen(input: {
+    platform: string;
+    status: number | null;
+    error?: unknown;
+}): BrowserOpenResult;
+export declare function hasNoGraphicalDisplay(platform: string, env: Record<string, string | undefined>): boolean;
 export declare class UsageError extends Error {
 }
 export {};

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.34.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);
+        }
+    }
+    // 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 };
+    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" });
@@ -755,6 +911,12 @@ async function deviceAuthFlow(options) {
         headers: { "content-type": "application/json" },
         body: JSON.stringify({ machineName: options.machineName ?? os.hostname(), purpose: options.purpose }),
     });
+    // The control plane refuses a signup it knows can never be approved (#507) with
+    // a message written for the tester. Surface it alone and stop here, rather than
+    // opening a browser and polling for something that will never arrive.
+    if (!startResponse.ok) {
+        throw new Error(await apiErrorMessage(startResponse, `start device ${options.purpose}`));
+    }
     const start = await expectJson(startResponse, `start device ${options.purpose}`);
     const userCode = start.user_code ?? start.code;
     const deviceCode = start.device_code;
@@ -763,29 +925,104 @@ async function deviceAuthFlow(options) {
     }
     console.log(`Open ${start.verification_uri}`);
     console.log(`Device code: ${userCode}`);
-    openBrowser(start.verification_uri);
+    // Everything new below goes to stderr (#509): stdout keeps exactly the two
+    // lines above plus the caller's unchanged result line, so anything already
+    // reading it is unaffected.
+    const progressStream = options.progressStream ?? process.stderr;
+    const browser = (options.openBrowserFn ?? openBrowser)(start.verification_uri);
+    if (browser === "failed") {
+        // Say it the moment it happens. A swallowed browser failure used to look
+        // exactly like a flow nobody had approved yet.
+        progressStream.write("Could not open a browser automatically.\n");
+    }
+    // Stated on every device auth, not only after a failure: the printed URL
+    // carries the code, so opening it anywhere finishes the flow. That recovery
+    // path has to be known before it is needed, not discovered by guesswork.
+    progressStream.write("Open the URL above in any browser — on this machine or another — to approve this device.\n");
     const deadline = Date.now() + start.expires_in * 1000;
     const intervalMs = Math.max(1, start.interval ?? 2) * 1000;
-    while (Date.now() < deadline) {
-        await sleep(intervalMs);
-        const pollResponse = await fetchFn(`${apiUrl}/v1/oauth/device/poll`, {
-            method: "POST",
-            headers: { "content-type": "application/json" },
-            body: JSON.stringify({ code: deviceCode }),
-        });
-        if (pollResponse.status === 400) {
-            continue;
-        }
-        if (pollResponse.status === 410) {
-            const body = await pollResponse.text();
-            throw new Error(`Device ${options.purpose} expired or was denied: ${body}`);
+    // stop() in a finally so no outcome — approval, denial, network throw,
+    // expiry — can leave the spinner timer alive or the line half-drawn.
+    const progress = createDeviceAuthProgressReporter(progressStream);
+    try {
+        while (Date.now() < deadline) {
+            // Tick before the sleep so the first feedback is immediate rather than
+            // one poll interval late. Remaining time is derived from the deadline the
+            // server's expires_in produced, never from a CLI-side constant.
+            progress.tick(deadline - Date.now());
+            await sleep(intervalMs);
+            const pollResponse = await fetchFn(`${apiUrl}/v1/oauth/device/poll`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify({ code: deviceCode }),
+            });
+            if (pollResponse.status === 400) {
+                continue;
+            }
+            if (pollResponse.status === 410) {
+                // The server distinguishes three terminal states behind this one status
+                // (expired / denied / consumed); the old branch collapsed them into one
+                // message and appended the raw JSON envelope. It also swallowed the
+                // actionable expiry guidance below: the server starts the clock before the
+                // client computes `deadline`, so a login left unapproved almost always ends
+                // HERE rather than by the loop running out — which made that guidance
+                // unreachable in the normal case (#514 review).
+                const state = await deviceTerminalState(pollResponse);
+                if (state === "denied") {
+                    throw new Error(`Device ${options.purpose} was declined in the browser. ` +
+                        `Run "9pm ${options.purpose}" again if that was not intended.`);
+                }
+                if (state === "consumed") {
+                    throw new Error(`Device ${options.purpose} code ${userCode} was already used. ` +
+                        `Run "9pm ${options.purpose}" again to get a fresh code.`);
+                }
+                // "expired", and anything unrecognised: expiry is what a 410 means here by
+                // default, and the guidance is useful either way.
+                throw new Error(expiredDeviceAuthMessage(options.purpose, userCode, start.expires_in * 1000, start.verification_uri));
+            }
+            const poll = await expectJson(pollResponse, `poll device ${options.purpose}`);
+            // Retire the spinner the moment approval lands, BEFORE credential storage
+            // and the account lookup. storeCredential can fall back to plaintext and
+            // warn on stderr, and whoami is an awaited round trip — either would have
+            // its output appended to an unterminated spinner line, and the redraw timer
+            // could fire again underneath it, corrupting the tail of a *successful*
+            // login (#514 review). stop() is idempotent, so the finally below stays as
+            // the fallback for every other exit path.
+            progress.stop();
+            const storage = (options.storeCredentialFn ?? storeCredential)(poll.token, {
+                allowFileFallback: options.allowFileCredentialStore,
+            });
+            const me = await whoami({ apiUrl, token: poll.token, fetchFn });
+            return { email: me.user.email, storage };
         }
-        const poll = await expectJson(pollResponse, `poll device ${options.purpose}`);
-        const storage = storeCredential(poll.token, { allowFileFallback: options.allowFileCredentialStore });
-        const me = await whoami({ apiUrl, token: poll.token, fetchFn });
-        return { email: me.user.email, storage };
     }
-    throw new Error(`Device ${options.purpose} expired before approval.`);
+    finally {
+        progress.stop();
+    }
+    // Reached only when the client's own deadline elapses without the server having
+    // said anything terminal — rarer than the 410 route above, but it must say the
+    // same thing, so both share one message.
+    throw new Error(expiredDeviceAuthMessage(options.purpose, userCode, start.expires_in * 1000, start.verification_uri));
+}
+// The actionable timeout guidance, shared by both routes out of an unapproved
+// device flow (the server's 410 and the client's own deadline) so they can never
+// drift into saying different things.
+export function expiredDeviceAuthMessage(purpose, userCode, lifetimeMs, verificationUri) {
+    return (`Device ${purpose} expired: code ${userCode} was not approved within ${formatRemainingForCli(lifetimeMs)}. ` +
+        `Run "9pm ${purpose}" again, then open the printed URL in any browser — on this machine or another — to approve it. ` +
+        `If no page ever loaded, check that ${verificationUri} is reachable from this network.`);
+}
+// Which terminal state the control plane meant by its 410. Returns "" when the
+// body is not the expected envelope, so callers fall back rather than guess.
+async function deviceTerminalState(response) {
+    const text = await response.text();
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed.state === "string" ? parsed.state : "";
+    }
+    catch {
+        return "";
+    }
 }
 async function createProject(fetchFn, apiUrl, token, body) {
     const response = await fetchFn(`${apiUrl}/v1/sites`, {
@@ -1149,7 +1386,8 @@ export async function uploadContainerImage(fetchFn, imagePath, upload, retry = C
         await dispatcher.close().catch(() => { });
     }
 }
-const UPLOAD_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+// Shared by every in-place stderr reporter in this file; do not duplicate.
+const CLI_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
 export function createUploadProgressReporter(stream = process.stderr) {
     const isTty = stream.isTTY === true;
     let timer;
@@ -1167,7 +1405,7 @@ export function createUploadProgressReporter(stream = process.stderr) {
     const redraw = () => {
         if (!last)
             return;
-        stream.write(`\r\x1b[K${UPLOAD_SPINNER_FRAMES[frame % UPLOAD_SPINNER_FRAMES.length]} ${label(last)}`);
+        stream.write(`\r\x1b[K${CLI_SPINNER_FRAMES[frame % CLI_SPINNER_FRAMES.length]} ${label(last)}`);
     };
     const stopTimer = () => {
         if (timer) {
@@ -1238,6 +1476,72 @@ export function createUploadProgressReporter(stream = process.stderr) {
         },
     };
 }
+// Off-TTY ceiling: at most one line per 30s of the window (~20 lines over 600s).
+const DEVICE_AUTH_PROGRESS_LINE_INTERVAL_MS = 30_000;
+export function createDeviceAuthProgressReporter(stream = process.stderr) {
+    const isTty = stream.isTTY === true;
+    let timer;
+    let frame = 0;
+    let finished = false;
+    let remainingMs;
+    let lastLineRemainingMs;
+    const label = (ms) => `Waiting for approval… ${formatRemainingForCli(ms)} left`;
+    const redraw = () => {
+        if (remainingMs === undefined)
+            return;
+        stream.write(`\r\x1b[K${CLI_SPINNER_FRAMES[frame % CLI_SPINNER_FRAMES.length]} ${label(remainingMs)}`);
+    };
+    const stopTimer = () => {
+        if (timer) {
+            clearInterval(timer);
+            timer = undefined;
+        }
+    };
+    return {
+        tick(nextRemainingMs) {
+            if (finished)
+                return;
+            const first = remainingMs === undefined;
+            remainingMs = nextRemainingMs;
+            if (isTty) {
+                redraw();
+                if (first) {
+                    // Sub-second liveness: the countdown itself only advances on a poll
+                    // boundary, which would look frozen for a whole interval at a time.
+                    timer = setInterval(() => {
+                        frame += 1;
+                        redraw();
+                    }, 120);
+                    // Never hold the process open on the reporter's account.
+                    if (typeof timer.unref === "function")
+                        timer.unref();
+                }
+                return;
+            }
+            if (lastLineRemainingMs !== undefined && lastLineRemainingMs - nextRemainingMs < DEVICE_AUTH_PROGRESS_LINE_INTERVAL_MS) {
+                return;
+            }
+            lastLineRemainingMs = nextRemainingMs;
+            stream.write(`${label(nextRemainingMs)}\n`);
+        },
+        // Idempotent; called from a finally around the poll loop. On a TTY it erases
+        // the in-place line and writes nothing in its place: unlike the upload
+        // reporter this deliberately leaves no ✓/✗ summary, because the flow's own
+        // success line or its thrown error is the outcome, and a second line here
+        // would be exactly the leftover progress noise #509 forbids. Off-TTY the
+        // lines are already terminated, and before the first tick there is nothing
+        // to clean up.
+        stop() {
+            if (finished)
+                return;
+            finished = true;
+            stopTimer();
+            if (isTty && remainingMs !== undefined) {
+                stream.write("\r\x1b[K");
+            }
+        },
+    };
+}
 function buildContainerImage(directory) {
     const root = path.resolve(directory);
     if (!existsSync(path.join(root, "Dockerfile"))) {
@@ -1291,6 +1595,25 @@ async function expectOk(response, action) {
     const text = await response.text();
     throw new Error(`Failed to ${action}: ${response.status} ${text}`);
 }
+// Pull the control plane's own message out of its {error:{code,message}} envelope,
+// for the few refusals whose message is written for the tester and is the whole
+// point of the response (e.g. device signup being unavailable, #507). Dumping the
+// raw envelope the way expectOk does would bury it in JSON. Falls back to
+// expectOk's text when the body isn't that shape, so this can never lose detail.
+async function apiErrorMessage(response, action) {
+    const text = await response.text();
+    try {
+        const parsed = JSON.parse(text);
+        const message = parsed.error?.message;
+        if (typeof message === "string" && message.trim()) {
+            return message.trim();
+        }
+    }
+    catch {
+        // Not JSON (proxy error page, empty body) — fall through to the raw form.
+    }
+    return `Failed to ${action}: ${response.status} ${text}`;
+}
 // #374: Node's fetch rejects network-level failures (no HTTP response at all)
 // as a generic "fetch failed" TypeError and stashes the real reason on
 // `error.cause` (e.g. { code: "EPIPE" }). That code never reaches the user.
@@ -1674,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}`);
@@ -2126,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) {
@@ -2538,10 +2883,45 @@ function deleteLinuxSecretServiceCredential() {
     const result = spawnSync("secret-tool", ["clear", "service", TOKEN_SERVICE, "account", TOKEN_ACCOUNT], { encoding: "utf8" });
     return result.status === 0;
 }
+// Pure and exported so the per-platform mapping is unit-testable without
+// spawning anything (#509). A spawn error or a non-zero exit is a real failure.
+// A zero exit means the handler ran — except on Windows, where the launcher
+// returns 0 whether or not anything actually rendered the page, so "opened"
+// there would be a claim we cannot back: report "unknown" and say nothing about
+// the browser rather than mislead. The unconditional paste-the-URL hint covers
+// that case anyway.
+export function classifyBrowserOpen(input) {
+    if (input.error !== undefined) {
+        return "failed";
+    }
+    if (input.status !== 0) {
+        return "failed";
+    }
+    return input.platform === "win32" ? "unknown" : "opened";
+}
+// Headless boxes, containers and remote SSH sessions — the cases where the
+// browser handoff is least likely to work, and where `xdg-open` often exits 0
+// having done nothing, so the absence of any display is the stronger signal.
+// Pure and exported for the same reason as classifyBrowserOpen: the branch has
+// to be assertable without a real platform or a real spawn. Note
+// noUncheckedIndexedAccess makes these `string | undefined`; an empty value is
+// as useless as an absent one, so test truthiness, not presence.
+export function hasNoGraphicalDisplay(platform, env) {
+    return platform === "linux" && !env["DISPLAY"] && !env["WAYLAND_DISPLAY"];
+}
 function openBrowser(url) {
+    if (hasNoGraphicalDisplay(process.platform, process.env)) {
+        return "failed";
+    }
     const command = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
     const args = process.platform === "win32" ? ["/c", "start", "", url] : [url];
-    spawnSync(command, args, { stdio: "ignore" });
+    // stdio stays ignored: a browser's own chatter must not pollute the terminal.
+    const result = spawnSync(command, args, { stdio: "ignore" });
+    return classifyBrowserOpen({
+        platform: process.platform,
+        status: result.status,
+        ...(result.error ? { error: result.error } : {}),
+    });
 }
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
@@ -2576,6 +2956,16 @@ function formatBytesForCli(value) {
     }
     return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
 }
+// Human remaining time for the device-auth wait (#509). Ceil so a window with
+// any time left never reads "0s", and clamp so a passed deadline reads "0s"
+// rather than a negative.
+function formatRemainingForCli(value) {
+    const totalSeconds = Math.max(0, Math.ceil(value / 1000));
+    if (totalSeconds < 60) {
+        return `${totalSeconds}s`;
+    }
+    return `${Math.floor(totalSeconds / 60)}m ${totalSeconds % 60}s`;
+}
 export class UsageError extends Error {
 }
 async function main() {
@@ -2603,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;
             }
@@ -2890,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() {
@@ -2914,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>
@@ -2939,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.34.0",
+  "version": "0.39.0",
   "description": "CLI for deploying built apps to 9pm.ai.",
   "homepage": "https://9pm.ai",
   "keywords": [