ninepm 0.53.0 → 0.56.0

package/README.md

@@ -110,7 +110,7 @@ Deploy a container app from a local Docker build:
 
 Container deploys require Docker locally. The CLI builds a `linux/amd64` image, exports it, checks image size against the per-app limit and account retained-image quota, uploads through a short-lived session, and finalizes a queued deployment. The container must listen on `0.0.0.0:$PORT` - always read the `PORT` env var rather than hardcoding the selected `--port`, since on some placements the platform holds the selected port and hands the app a different one; set `--health-path` when the app has a cheap readiness endpoint.
 
-Use `--with-db` when the container needs managed SQL. The app receives `NINEPM_SQL_URL` and `NINEPM_DB_BINDINGS`; send `POST` requests to `NINEPM_SQL_URL` with `{ "binding": "DB", "sql": "SELECT 1", "params": [] }`. For local development, use the app's normal local database adapter behind a repository layer and keep deployed SQL compatible with SQLite.
+Use `--with-db` when the container needs managed SQL. The app receives `NINEPM_SQL_URL` and `NINEPM_DB_BINDINGS`; send `POST` requests to `NINEPM_SQL_URL` with `{ "binding": "DB", "sql": "SELECT 1", "params": [] }`. Some placements also set `NINEPM_SQL_TOKEN` — when it is present, send `Authorization: Bearer <that token>` on every request, or the bridge refuses them all with `401 {"error":"unauthorized"}`. Read the URL and the token from the environment on each call rather than hardcoding either: the URL differs between placements, and the token is reissued on every deploy. For local development, use the app's normal local database adapter behind a repository layer and keep deployed SQL compatible with SQLite.
 
 Regions are provider-neutral: `auto`, `us-east`, `us-west`, `europe`, `asia`, `south-america`, `middle-east`, `oceania`, `africa`.
 

package/dist/cli-types.d.ts

@@ -16,6 +16,13 @@ export interface Project {
     createdAt: string;
     updatedAt: string;
 }
+export interface AppUserFilesUsage {
+    usedBytes: number;
+    pendingBytes: number;
+    ceilingBytes: number;
+    ceilingIsDefault: boolean;
+    fileCount: number;
+}
 export interface FileManifestEntry {
     path: string;
     size: number;

package/dist/deploy-limits.js

@@ -33,7 +33,14 @@ export function formatKilobytes(bytes) {
     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)}.`;
+    // Carries the remedy as well as the ceiling, and only a remedy that holds for EVERY
+    // oversized file: this runs over the whole manifest, so the file may be the configured
+    // worker entry, where "leave it out" produces a missing-entry failure instead. Shrinking
+    // is the one option that is always available. Deliberately silent on HOW — that depends
+    // on the file, and "compress the image" reads as advice from something that has looked
+    // at it.
+    return (`File "${filePath}" is ${formatMebibytes(size)}; individual files are limited to ${formatMebibytes(MAX_STATIC_ASSET_FILE_BYTES)}. ` +
+        "Shrink the file before deploying again.");
 }
 // Manifest entries that exceed the per-file limit. A structural type keeps this
 // module free of cross-tree type imports so it copies cleanly into the CLI.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Agent } from "undici";
-import type { AccessGrant, AccessGrantType, AccessProviderKey, AppAccessSettings, AppAccessServiceToken, AppAccessToken, AppDatabase, AppRuntime, ContainerImageUploadInstruction, ContainerRegion, Deployment, ManagedFileObject, ManagedFileShare, ManagedFileUsage, Project } from "./cli-types.js";
+import type { AccessGrant, AccessGrantType, AccessProviderKey, AppAccessSettings, AppAccessServiceToken, AppAccessToken, AppDatabase, AppRuntime, AppUserFilesUsage, ContainerImageUploadInstruction, ContainerRegion, Deployment, ManagedFileObject, ManagedFileShare, ManagedFileUsage, Project } from "./cli-types.js";
 export interface DeployOptions {
     directory: string;
     apiUrl: string;
@@ -114,7 +114,7 @@ export interface CreatedServiceToken {
     clientSecret: string;
 }
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-export declare const CLI_VERSION = "0.53.0";
+export declare const CLI_VERSION = "0.56.0";
 type CredentialBackend = "macos-keychain" | "windows-dpapi" | "linux-secret-service" | "file-plaintext" | "none";
 export interface StoredCredentialEntry {
     token: string;
@@ -351,6 +351,9 @@ export declare function signupDevice(options: {
 }>;
 export declare function expiredDeviceAuthMessage(purpose: string, userCode: string, lifetimeMs: number, verificationUri: string): string;
 export declare function listManagedFiles(options: FileCommandOptions): Promise<ManagedFileListResult>;
+export declare function getAppUserFilesUsage(options: ApiOptions & {
+    site: string;
+}): Promise<AppUserFilesUsage>;
 export declare function putManagedFile(options: FilePutOptions): Promise<ManagedFilePutResult>;
 export declare function getManagedFile(options: FileGetOptions): Promise<{
     fileId: string;
@@ -450,6 +453,10 @@ type CliCommand = {
     action: {
         kind: "list";
         project?: string;
+    } | {
+        kind: "usage";
+        project?: string;
+        json: boolean;
     } | {
         kind: "put";
         localPath: string;
@@ -589,6 +596,7 @@ export declare function classifyBrowserOpen(input: {
     error?: unknown;
 }): BrowserOpenResult;
 export declare function hasNoGraphicalDisplay(platform: string, env: Record<string, string | undefined>): boolean;
+export declare function formatAppUserFilesUsageLine(slug: string, usage: AppUserFilesUsage): string;
 export declare class UsageError extends Error {
 }
 export {};

package/dist/index.js

@@ -14,7 +14,7 @@ import { MAX_DEPLOY_DESCRIPTION_LENGTH, normalizeDeployDescription } from "./dep
 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.53.0";
+export const CLI_VERSION = "0.56.0";
 const PUBLIC_DASHBOARD_URL = "https://9pm.ai/dashboard";
 const TOKEN_SERVICE = "9pm";
 const TOKEN_ACCOUNT = "default";
@@ -1450,6 +1450,11 @@ async function apiRequest(options, route, init) {
 export async function listManagedFiles(options) {
     return apiRequest(options, filesRoute(options), { method: "GET" });
 }
+// Per-app user-file usage + ceiling (files an app's signed-in end users uploaded through
+// ctx.files) — a different endpoint from the owner's own managed-file library above.
+export async function getAppUserFilesUsage(options) {
+    return apiRequest(options, `/v1/sites/${encodeURIComponent(options.site)}/files/usage`, { method: "GET" });
+}
 export async function putManagedFile(options) {
     const fetchFn = options.fetchFn ?? fetch;
     const apiUrl = normalizeApiUrl(options.apiUrl);
@@ -2426,6 +2431,15 @@ function parseFilesArgs(argv) {
     if (subcommand === "list") {
         return { kind: "files", ...base, action: { kind: "list", ...withProject } };
     }
+    if (subcommand === "usage") {
+        // Per-app user-file usage. --project scopes to one app; omitting it entirely is the
+        // account-wide overview. But a present-but-empty --project/--site is a typo, not the
+        // overview: reject it rather than silently fanning out over every app.
+        if ((flags.has("project") || flags.has("site")) && !project) {
+            throw new Error("--project needs an app slug, e.g. `9pm files usage --project my-app`.");
+        }
+        return { kind: "files", ...base, action: { kind: "usage", ...withProject, json: flags.has("json") } };
+    }
     if (subcommand === "put") {
         const localPath = argv[1];
         if (!localPath || localPath.startsWith("--")) {
@@ -3831,6 +3845,19 @@ function formatBytesForCli(value) {
     }
     return `${(bytes / 1024 / 1024 / 1024).toFixed(1)}GB`;
 }
+// One `9pm files usage` row: "<slug>\t<used> / <ceiling> (<pct>%)\t<n> files", mirroring
+// the `used of total (percent%)` disk-usage style.
+export function formatAppUserFilesUsageLine(slug, usage) {
+    const ceiling = usage.ceilingIsDefault ? `${formatBytesForCli(usage.ceilingBytes)} (default)` : formatBytesForCli(usage.ceilingBytes);
+    // Used-over-ceiling has no meaningful percent — a zero-byte ceiling with files, or a
+    // ceiling lowered below current usage — so say "over limit" instead of a misleading 0%.
+    const status = usage.usedBytes > usage.ceilingBytes
+        ? "over limit"
+        : usage.ceilingBytes > 0
+            ? `${Math.round((usage.usedBytes / usage.ceilingBytes) * 100)}%`
+            : "0%";
+    return `${slug}\t${formatBytesForCli(usage.usedBytes)} / ${ceiling} (${status})\t${usage.fileCount} files`;
+}
 // 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.
@@ -4285,6 +4312,44 @@ async function runFilesCommand(command) {
         console.log(`Usage: ${formatBytesForCli(listed.usage.usedBytes)} / ${formatBytesForCli(listed.usage.quotaBytes)}`);
         return;
     }
+    if (command.action.kind === "usage") {
+        const action = command.action;
+        if (action.project) {
+            const usage = await getAppUserFilesUsage({ ...base, site: action.project });
+            if (action.json) {
+                console.log(JSON.stringify({ project: action.project, ...usage }, null, 2));
+                return;
+            }
+            console.log(formatAppUserFilesUsageLine(action.project, usage));
+            return;
+        }
+        // No --project: usage across every app the account owns. A dedicated overview, so the
+        // per-app fan-out (one usage call each, in parallel) lives here rather than slowing the
+        // plain `9pm apps` inventory.
+        const { projects } = await listSites(base);
+        // Isolate per-app failures: one app erroring (a transient 5xx, or a project deleted
+        // between listSites and here) must not blank the rest of the table.
+        const rows = await Promise.all(projects.map(async (p) => {
+            try {
+                return { slug: p.slug, usage: await getAppUserFilesUsage({ ...base, site: p.id }) };
+            }
+            catch {
+                return { slug: p.slug, usage: null };
+            }
+        }));
+        if (action.json) {
+            console.log(JSON.stringify(rows.map((r) => (r.usage ? { project: r.slug, ...r.usage } : { project: r.slug, unavailable: true })), null, 2));
+            return;
+        }
+        if (rows.length === 0) {
+            console.log("No apps. Run `9pm deploy` to create one.");
+            return;
+        }
+        for (const row of rows) {
+            console.log(row.usage ? formatAppUserFilesUsageLine(row.slug, row.usage) : `${row.slug}\t(usage unavailable)`);
+        }
+        return;
+    }
     if (command.action.kind === "put") {
         const result = await putManagedFile({ ...base, ...project, localPath: command.action.localPath, ...(command.action.remotePath ? { remotePath: command.action.remotePath } : {}) });
         console.log(`Stored ${result.file.path} (${formatBytesForCli(result.file.size)}).`);
@@ -4346,6 +4411,7 @@ function printUsage() {
   9pm latest [--json]
   9pm support -m "<what happened>" [--subject <subject>] [--site <app>]
   9pm files list [--project <site>]
+  9pm files usage [--project <site>] [--json]
   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] [--public] [--project <site>]
@@ -4385,7 +4451,7 @@ Size limits:
 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 - always read the PORT env var; on some placements the platform holds the selected --port and hands the app a different one. Use --health-path for a cheap readiness endpoint.
-  With --with-db, containers receive NINEPM_SQL_URL and NINEPM_DB_BINDINGS for the managed SQL bridge.
+  With --with-db, containers receive NINEPM_SQL_URL and NINEPM_DB_BINDINGS for the managed SQL bridge, plus NINEPM_SQL_TOKEN where that bridge requires one - send it as "Authorization: Bearer <token>" or every query is refused.
   With --with-auth, the app gets 9pm-managed end-user accounts (email one-time codes); it implies --with-db and is one-way (enable-only).
   With --with-email, a signed-in end user can send app invitation emails; it implies --with-auth and works on public apps only.
   9pm env set <app> KEY=value [KEY2=value2 ...] [--var]   (secret by default; --var = readable config)

package/package.json

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