ninepm 0.27.0 → 0.30.0

package/dist/cli-types.d.ts

@@ -41,6 +41,7 @@ export interface ContainerImageUploadInstruction {
     expiresAt: string;
     maxBytes: number;
     partBytes?: number;
+    uploadId?: string;
     headers: Record<string, string>;
 }
 export interface AppDatabase {

package/dist/index.d.ts

@@ -29,6 +29,7 @@ export interface DeployOptions {
     pollTimeoutMs?: number;
     fetchFn?: FetchLike;
     check?: boolean;
+    onUploadProgress?: UploadProgress;
 }
 export interface DeployResult {
     project: Project;
@@ -48,6 +49,7 @@ export interface SiteAccessOptions extends ApiOptions {
 }
 export interface DeleteSiteOptions extends SiteAccessOptions {
     confirmSlug: string;
+    keepRecord?: boolean;
 }
 export interface AccessState {
     access: AppAccessSettings;
@@ -110,7 +112,7 @@ export interface CreatedServiceToken {
     clientSecret: string;
 }
 export type FetchLike = (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
-export declare const CLI_VERSION = "0.27.0";
+export declare const CLI_VERSION = "0.30.0";
 type CredentialBackend = "macos-keychain" | "windows-dpapi" | "linux-secret-service" | "file-plaintext" | "none";
 export interface CredentialDiagnostics {
     platform: NodeJS.Platform;
@@ -270,11 +272,24 @@ export interface UploadRetryOptions {
     baseDelayMs: number;
     retryNetworkErrors?: boolean;
 }
+export interface UploadProgressEvent {
+    phase: "start" | "part" | "done";
+    part: number;
+    totalParts: number;
+    uploadedBytes: number;
+    totalBytes: number;
+}
+export type UploadProgress = (event: UploadProgressEvent) => void;
 type ContainerUploadInit = RequestInit & {
     dispatcher?: Agent;
 };
 export declare function uploadRequestWithRetry(fetchFn: FetchLike, url: string, init: ContainerUploadInit, label: string, sizeBytes: number, options?: UploadRetryOptions): Promise<Response>;
-export declare function uploadContainerImage(fetchFn: FetchLike, imagePath: string, upload: ContainerImageUploadInstruction, retry?: UploadRetryOptions): Promise<void>;
+export declare function uploadContainerImage(fetchFn: FetchLike, imagePath: string, upload: ContainerImageUploadInstruction, retry?: UploadRetryOptions, onProgress?: UploadProgress): Promise<void>;
+export interface UploadProgressReporter {
+    onProgress: UploadProgress;
+    stop(): void;
+}
+export declare function createUploadProgressReporter(stream?: NodeJS.WriteStream): UploadProgressReporter;
 type CliCommand = {
     kind: "deploy";
     options: DeployOptions;

package/dist/index.js

@@ -12,7 +12,7 @@ import { MAX_DEPLOY_DESCRIPTION_LENGTH, normalizeDeployDescription } from "./dep
 import { assetFileTooLargeMessage, oversizedAssets } 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.27.0";
+export const CLI_VERSION = "0.30.0";
 const PUBLIC_DASHBOARD_URL = "https://9pm.ai/dashboard";
 const TOKEN_SERVICE = "9pm";
 const TOKEN_ACCOUNT = "default";
@@ -197,10 +197,19 @@ export async function deployDirectory(initialOptions) {
     }
     catch (error) {
         // If this invocation created the project (vs. redeploying an existing app)
-        // and the deploy then failed, roll the project back so a rejected first
-        // deploy leaves no orphaned app holding the slug and a Sites quota slot
-        // (#195). Best-effort: a cleanup failure must not mask the deploy error.
-        if (slugHolder.created && slugHolder.slug) {
+        // and the deploy then failed, tear the project's resources back down so a
+        // rejected first deploy leaves no orphaned Worker/machine, slug, or Sites
+        // quota slot (#195). When the failure left a queryable record (`retain`), pass
+        // keepRecord so the live resources are still reclaimed now but the project +
+        // failed deployment + captured logs survive for `9pm logs` — the control plane
+        // sweeps the leftover record after a retention window (#403). A failed
+        // redeploy of a retained failed-only project (created=false, never active)
+        // gets the same keepRecord teardown: there's no live app to protect, and
+        // without it the new attempt's resources would linger until the sweep. A
+        // project this invocation didn't create is never fully deleted. Best-effort
+        // either way: a cleanup failure must not mask the deploy error.
+        const teardownRetainedRedeploy = !slugHolder.created && slugHolder.neverActive === true && slugHolder.retain === true;
+        if (slugHolder.slug && (slugHolder.created || teardownRetainedRedeploy)) {
             try {
                 await deleteSite({
                     apiUrl: initialOptions.apiUrl,
@@ -208,6 +217,7 @@ export async function deployDirectory(initialOptions) {
                     ...(initialOptions.fetchFn ? { fetchFn: initialOptions.fetchFn } : {}),
                     site: slugHolder.slug,
                     confirmSlug: slugHolder.slug,
+                    ...(slugHolder.retain ? { keepRecord: true } : {}),
                 });
             }
             catch {
@@ -239,6 +249,7 @@ async function runDeploy(initialOptions, slugHolder) {
             const { project, created: projectCreated } = await createProject(fetchFn, apiUrl, options.token, options.slug ? { ...projectInput, slug: options.slug } : projectInput);
             slugHolder.slug = project.slug;
             slugHolder.created = projectCreated;
+            slugHolder.neverActive = project.activeDeploymentId === null;
             const database = options.withDatabase
                 ? await createDatabase(fetchFn, apiUrl, options.token, project.id, {
                     name: options.databaseName ?? `${project.slug}-db`,
@@ -287,25 +298,44 @@ async function runDeploy(initialOptions, slugHolder) {
             // npm undici@7 Agent to Node's bundled fetch (undici 6.x on Node 20/22)
             // crosses a major-version dispatch-handler boundary; keeping both on the
             // installed undici avoids that mismatch. Tests still inject their own fetch.
-            await uploadContainerImage(options.fetchFn ?? undiciFetchLike, image.path, created.containerImageUpload);
+            // Live upload feedback (#404): a large image over a slow uplink otherwise
+            // uploads in total silence and looks hung. options.onUploadProgress is the
+            // explicit seam; without it, an injected fetchFn is our signal for a
+            // programmatic/test caller (the bundled CLI never sets it — parseDeployArgs
+            // builds options purely from argv), so only the real CLI run gets the
+            // implicit stderr reporter. stop() in the finally is a no-op on success and
+            // closes the spinner (timer + line) on failure, so the reporter can't
+            // outlive the upload.
+            const uploadProgress = options.onUploadProgress || options.fetchFn ? undefined : createUploadProgressReporter();
+            try {
+                await uploadContainerImage(options.fetchFn ?? undiciFetchLike, image.path, created.containerImageUpload, undefined, options.onUploadProgress ?? uploadProgress?.onProgress);
+            }
+            finally {
+                uploadProgress?.stop();
+            }
             const queued = await finalizeDeployment(fetchFn, apiUrl, options.token, created.deployment.id);
             const finalized = await pollDeployment(fetchFn, apiUrl, options.token, queued.id, options.pollTimeoutMs ?? DEFAULT_CONTAINER_POLL_TIMEOUT_MS, queued);
             if (finalized.status === "failed") {
-                // #374: the deployment's own message is the neutral reason + support
-                // ref. Inline a bounded tail of the build/push log when we can fetch it
-                // (captured now, before any first-deploy rollback), so the output names
-                // the real cause without a separate command.
+                // The deploy left a finalized failure record. Keep it (skip the #195
+                // first-deploy rollback) so `9pm logs` / `9pm deployments ls` work for a
+                // first-time crash-on-boot — the exact moment the debugging surface used
+                // to disappear (#403). The control plane reclaims it after a retention
+                // window, so this doesn't re-introduce a permanent orphan.
+                slugHolder.retain = true;
+                // #374: the deployment's own message is the neutral reason + support ref.
+                // Inline a bounded tail of the captured container output when we can fetch
+                // it, so the output names the real cause without a separate command.
                 const parts = [deploymentFailureMessage(finalized)];
                 const detail = await containerFailureDetail({ apiUrl, token: options.token, fetchFn }, project.slug, finalized.id);
                 if (detail) {
-                    parts.push(`Container build/push log (tail):\n${detail}`);
-                }
-                // The `9pm logs` pointer only helps while the app still exists. A failed
-                // first deploy is rolled back (deleted) by deployDirectory's catch, so
-                // the command would 404 — only offer it for redeploys of a surviving app.
-                if (!slugHolder.created) {
-                    parts.push(`Run '9pm logs ${project.slug}' for the full container build/push log.`);
+                    // Neutral label on purpose: the captured text is the container's own
+                    // output when the placement could obtain it (#403), else the build/push
+                    // or health detail — the server doesn't tell us which, so don't claim.
+                    parts.push(`Failure log (tail):\n${detail}`);
                 }
+                // The record now survives a failed first deploy too, so always point at
+                // `9pm logs` for the full captured log.
+                parts.push(`Run '9pm logs ${quoteSiteArg(project.slug)}' for the full failure log.`);
                 throw new Error(parts.join("\n\n"));
             }
             return {
@@ -663,7 +693,7 @@ export async function listSites(options) {
 export async function deleteSite(options) {
     const payload = await apiRequest(options, `/v1/sites/${encodeURIComponent(options.site)}`, {
         method: "DELETE",
-        body: JSON.stringify({ confirmSlug: options.confirmSlug }),
+        body: JSON.stringify({ confirmSlug: options.confirmSlug, ...(options.keepRecord ? { keepRecord: true } : {}) }),
     });
     return payload.deleted;
 }
@@ -983,7 +1013,7 @@ export async function uploadRequestWithRetry(fetchFn, url, init, label, sizeByte
     }
     throw new Error(`Failed to ${label} after ${attempts} attempts (${formatBytesForCli(sizeBytes)}): ${lastError}`);
 }
-export async function uploadContainerImage(fetchFn, imagePath, upload, retry = CONTAINER_UPLOAD_RETRY) {
+export async function uploadContainerImage(fetchFn, imagePath, upload, retry = CONTAINER_UPLOAD_RETRY, onProgress) {
     // Back the body with the file on disk instead of reading it all into memory:
     // slices are lazy views, so peak memory stays flat regardless of image size,
     // and a retried attempt just re-reads the same blob.
@@ -992,6 +1022,14 @@ export async function uploadContainerImage(fetchFn, imagePath, upload, retry = C
     if (totalBytes > upload.maxBytes) {
         throw new Error(`Container image is ${totalBytes} bytes; upload session allows ${upload.maxBytes} bytes.`);
     }
+    // Single source of truth for the chunking decision: the start event's
+    // totalParts and the actual upload branch below both derive from these, so
+    // the advertised part count can't drift from the parts actually sent.
+    // completeUrl is non-null exactly when the upload is multipart.
+    const partBytes = upload.partBytes && upload.partBytes > 0 ? upload.partBytes : 0;
+    const completeUrl = partBytes && upload.completeUrl && totalBytes > partBytes ? upload.completeUrl : null;
+    const totalParts = completeUrl ? Math.ceil(totalBytes / partBytes) : 1;
+    onProgress?.({ phase: "start", part: 0, totalParts, uploadedBytes: 0, totalBytes });
     // Disable undici's headers/body timeouts for the upload: on a slow link the
     // server sends no response headers until the whole body arrives, so the
     // default 300s timeouts abort a slow-but-live transfer. Keep a bounded
@@ -1005,26 +1043,27 @@ export async function uploadContainerImage(fetchFn, imagePath, upload, retry = C
         connect: { timeout: 30_000 },
     });
     try {
-        const partBytes = upload.partBytes && upload.partBytes > 0 ? upload.partBytes : 0;
-        if (!partBytes || !upload.completeUrl || totalBytes <= partBytes) {
+        if (!completeUrl) {
             // A single PUT writes the whole object at a content-addressed key, so a
             // re-send is idempotent and safe to retry.
             const response = await uploadRequestWithRetry(fetchFn, upload.uploadUrl, { method: upload.method, headers: upload.headers, body: image, dispatcher }, "upload container image", totalBytes, retry);
             await discardResponseBody(response);
+            onProgress?.({ phase: "part", part: 1, totalParts, uploadedBytes: totalBytes, totalBytes });
+            onProgress?.({ phase: "done", part: 1, totalParts, uploadedBytes: totalBytes, totalBytes });
             return;
         }
         // Large images go up in parts so no single request exceeds the platform's
         // request-body limits.
-        const totalParts = Math.ceil(totalBytes / partBytes);
-        let uploadId = "";
+        // A modern server issues the multipart uploadId up front (#391), so part 1
+        // carries it from the start and is as retryable as parts 2..N. Fall back to
+        // an empty id for older servers: there part 1 is uploadId-less, the server
+        // starts a fresh session for it, and a blind retry would orphan the first —
+        // so the guard below keeps part 1 single-attempt only in that legacy case.
+        let uploadId = upload.uploadId ?? "";
         const parts = [];
         for (let part = 1; part <= totalParts; part += 1) {
             const chunk = image.slice((part - 1) * partBytes, Math.min(part * partBytes, totalBytes));
             const query = uploadId ? `?part=${part}&uploadId=${encodeURIComponent(uploadId)}` : `?part=${part}`;
-            // Part 1 has no uploadId yet, so the server starts a fresh multipart
-            // upload for it — retrying a part 1 whose response was lost would orphan
-            // the first upload's parts. Send it once; parts 2..N carry the uploadId
-            // and are safe to retry.
             const partRetry = uploadId ? retry : { ...retry, attempts: 1 };
             const response = await uploadRequestWithRetry(fetchFn, `${upload.uploadUrl}${query}`, { method: upload.method, headers: upload.headers, body: chunk, dispatcher }, `upload container image part ${part}/${totalParts}`, chunk.size, partRetry);
             const payload = (await response.json());
@@ -1033,23 +1072,120 @@ export async function uploadContainerImage(fetchFn, imagePath, upload, retry = C
             }
             uploadId = payload.uploadId;
             parts.push({ part, etag: payload.etag });
+            onProgress?.({
+                phase: "part",
+                part,
+                totalParts,
+                uploadedBytes: Math.min(part * partBytes, totalBytes),
+                totalBytes,
+            });
         }
         // Completing consumes the uploadId server-side, so it is not idempotent: if
         // this succeeds but the response is lost, a blind re-send 500s on the gone
         // uploadId. Retry only explicit retryable statuses (server says "not done"),
         // never an ambiguous network error.
-        const completed = await uploadRequestWithRetry(fetchFn, upload.completeUrl, {
+        const completed = await uploadRequestWithRetry(fetchFn, completeUrl, {
             method: "POST",
             headers: { ...upload.headers, "content-type": "application/json" },
             body: JSON.stringify({ uploadId, parts }),
             dispatcher,
         }, "complete container image upload", totalBytes, { ...retry, retryNetworkErrors: false });
         await discardResponseBody(completed);
+        onProgress?.({ phase: "done", part: totalParts, totalParts, uploadedBytes: totalBytes, totalBytes });
     }
     finally {
         await dispatcher.close().catch(() => { });
     }
 }
+const UPLOAD_SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+export function createUploadProgressReporter(stream = process.stderr) {
+    const isTty = stream.isTTY === true;
+    let timer;
+    let frame = 0;
+    let finished = false;
+    let last;
+    const label = (event) => {
+        const total = formatBytesForCli(event.totalBytes);
+        if (event.totalParts > 1) {
+            const shown = Math.max(1, event.part);
+            return `Uploading image… part ${shown}/${event.totalParts} · ${formatBytesForCli(event.uploadedBytes)} / ${total}`;
+        }
+        return `Uploading image… ${total}`;
+    };
+    const redraw = () => {
+        if (!last)
+            return;
+        stream.write(`\r\x1b[K${UPLOAD_SPINNER_FRAMES[frame % UPLOAD_SPINNER_FRAMES.length]} ${label(last)}`);
+    };
+    const stopTimer = () => {
+        if (timer) {
+            clearInterval(timer);
+            timer = undefined;
+        }
+    };
+    const finalize = (line) => {
+        if (finished)
+            return;
+        finished = true;
+        stopTimer();
+        if (isTty) {
+            // Clear the in-place spinner line, then leave a clean final line behind.
+            stream.write(`\r\x1b[K${line}\n`);
+        }
+        else {
+            stream.write(`${line}\n`);
+        }
+    };
+    const onProgress = (event) => {
+        if (finished)
+            return;
+        last = event;
+        if (event.phase === "done") {
+            finalize(`✓ Uploaded image (${formatBytesForCli(event.totalBytes)})`);
+            return;
+        }
+        if (isTty) {
+            if (event.phase === "start") {
+                // Animate a spinner so a single long part still visibly moves.
+                redraw();
+                timer = setInterval(() => {
+                    frame += 1;
+                    redraw();
+                }, 120);
+                if (typeof timer.unref === "function")
+                    timer.unref();
+            }
+            else {
+                redraw();
+            }
+            return;
+        }
+        // Non-TTY: one line at start, and one per part boundary for multipart uploads.
+        if (event.phase === "start") {
+            stream.write(`Uploading image (${formatBytesForCli(event.totalBytes)})…\n`);
+        }
+        else if (event.totalParts > 1) {
+            stream.write(`Uploaded part ${event.part}/${event.totalParts} (${formatBytesForCli(event.uploadedBytes)} / ${formatBytesForCli(event.totalBytes)})\n`);
+        }
+    };
+    return {
+        onProgress,
+        // Structural cleanup for the failure path: no-op after done; otherwise stop
+        // the timer and close the line. Skip the "✗" line when no progress was ever
+        // shown (a pre-upload validation throw) — the real error prints right after,
+        // and a failure label for an upload that never started would mislabel it.
+        stop() {
+            if (finished)
+                return;
+            if (last) {
+                finalize("✗ Image upload failed");
+                return;
+            }
+            finished = true;
+            stopTimer();
+        },
+    };
+}
 function buildContainerImage(directory) {
     const root = path.resolve(directory);
     if (!existsSync(path.join(root, "Dockerfile"))) {
@@ -1699,7 +1835,13 @@ async function runLogsCommand(command) {
         if (command.lines !== undefined) {
             lines = lines.slice(-command.lines);
         }
+        // The reason above is the platform's verdict; this block is the captured
+        // failure detail — the container's own output when the placement could
+        // obtain it (#403), else the build/push or health detail. Neutral label:
+        // the server doesn't tell us which, so don't claim app output when it may
+        // be platform output.
         console.log("");
+        console.log("Failure log:");
         for (const line of lines) {
             console.log(line);
         }

package/package.json

@@ -1,7 +1,13 @@
 {
   "name": "ninepm",
-  "version": "0.27.0",
+  "version": "0.30.0",
   "description": "CLI for deploying built apps to 9pm.ai.",
+  "homepage": "https://9pm.ai",
+  "keywords": [
+    "9pm",
+    "deploy",
+    "cli"
+  ],
   "type": "module",
   "license": "SEE LICENSE IN LICENSE.md",
   "publishConfig": {
@@ -21,22 +27,10 @@
     "README.md",
     "LICENSE.md"
   ],
-  "scripts": {
-    "generate": "node ../../scripts/generate-cli-package.mjs",
-    "prebuild": "node ../../scripts/generate-cli-package.mjs",
-    "build": "tsc -p tsconfig.json",
-    "pretypecheck": "node ../../scripts/generate-cli-package.mjs",
-    "typecheck": "tsc --noEmit -p tsconfig.json",
-    "prepack": "npm run build"
-  },
   "engines": {
     "node": ">=20.18.1"
   },
   "dependencies": {
     "undici": "^7.10.0"
-  },
-  "devDependencies": {
-    "@types/node": "^24.10.1",
-    "typescript": "^5.9.3"
   }
 }