@getxflow/cli 0.9.0 → 0.10.0

package/README.md

@@ -20,7 +20,7 @@ else's code belongs next to it.
 | `org` / `org switch` | organizations with a stored key, and which one this folder works with |
 | `init` / `link` / `templates` | new project, link a folder to an existing one, which templates there are |
 | `status` / `pull` | state of the sources on the server and fetching them back |
-| `deploy` / `publish` / `rollback` / `deployments` | build, publish, roll back, version history |
+| `deploy` / `publish` / `rollback` / `deployments` | build, publish, serve earlier pages, version history |
 | `db status` / `db migrate` | migrations from `migrations/*.sql` with a gate on destructive ones |
 | `db schema` / `db query` | tables and columns, reading data in a read-only transaction |
 | `functions list` | cloud functions of the project from `functions/<name>/index.ts`, shipped by `deploy` |

package/dist/bin.js

@@ -24,6 +24,7 @@ const org_1 = require("./commands/org");
 const schedules_1 = require("./commands/schedules");
 const skills_1 = require("./commands/skills");
 const sources_1 = require("./commands/sources");
+const storage_1 = require("./commands/storage");
 const deploy_1 = require("./commands/deploy");
 const update_1 = require("./commands/update");
 async function run(args) {
@@ -164,6 +165,20 @@ async function run(args) {
                 return;
             }
             throw new errors_1.CliError(`Unknown command: db ${second}`, 'Available: status, schema, query and migrate');
+        case 'storage':
+            if (second === 'push') {
+                await (0, storage_1.storagePush)(rest);
+                return;
+            }
+            if (second === 'rm' || second === 'remove') {
+                await (0, storage_1.storageRemove)(rest);
+                return;
+            }
+            if (second === undefined || second === 'ls' || second === 'list') {
+                await (0, storage_1.storageList)(rest);
+                return;
+            }
+            throw new errors_1.CliError(`Unknown command: storage ${second}`, 'Available: ls, push and rm');
         case 'status':
             await (0, sources_1.status)();
             return;

package/dist/commands/deploy.js

@@ -18,6 +18,8 @@ const sources_1 = require("./sources");
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 /** Slightly longer than the platform's own build timeout. */
 const WAIT_LIMIT_MS = 16 * 60_000;
+/** Said the same way with a terminal and without one. */
+const REMOVAL_IS_FINAL = 'Removal is final: a function created again later gets a different address, schedules included';
 /** Print every check violation at once. */
 function reportIssues(e) {
     const issues = e.issues ?? [];
@@ -81,13 +83,19 @@ async function startBuild(client, projectId, revision, allowRemovals) {
     catch (e) {
         if (e instanceof api_1.ApiError && e.issues?.length)
             reportIssues(e);
-        const removing = e instanceof api_1.ApiError && e.code === 'confirm_required' ? (e.removing ?? []) : [];
-        // No terminal (CI, an agent): the flag is the only way to say yes, and the
-        // platform message already names it.
-        if (removing.length === 0 || process.stdin.isTTY !== true || process.stderr.isTTY !== true)
+        if (!(e instanceof api_1.ApiError) || e.code !== 'confirm_required')
             throw e;
+        const removing = e.removing ?? [];
+        if (removing.length === 0)
+            throw e;
+        // No terminal (CI, an agent): the flag is the only way to say yes. The platform
+        // hint names the API field, so translate it into the flag this CLI accepts.
+        if (process.stdin.isTTY !== true || process.stderr.isTTY !== true) {
+            throw new errors_1.CliError(e.message, `${REMOVAL_IS_FINAL}. If that is intended, retry with --allow-removals. ` +
+                'If it is not, bring the functions/<name>/index.ts directories back');
+        }
         (0, ui_1.warn)(`Gone from the sources, the build would remove them: ${removing.join(', ')}`);
-        (0, ui_1.note)((0, ui_1.dim)('  Removal is final: a function created again later gets a different address, schedules included'));
+        (0, ui_1.note)((0, ui_1.dim)(`  ${REMOVAL_IS_FINAL}`));
         const answer = await (0, prompt_1.select)('Remove them from the cloud?', [
             { label: 'No, stop here', hint: 'bring the functions/<name>/index.ts directories back' },
             { label: 'Yes, remove and build', hint: removing.join(', ') },
@@ -158,7 +166,9 @@ async function deploy(args) {
     catch {
         (0, ui_1.warn)('Could not refresh the function addresses in .env, the build itself is fine');
     }
-    (0, ui_1.note)((0, ui_1.dim)('  Show it to visitors: xflow publish'));
+    (0, ui_1.note)((0, ui_1.dim)('  The cloud functions of this build are already live: they are one per project'));
+    (0, ui_1.note)((0, ui_1.dim)('  and are not held back by publishing'));
+    (0, ui_1.note)((0, ui_1.dim)('  Show the new pages to visitors: xflow publish'));
 }
 async function publish() {
     const { root, config } = (0, config_1.requireProject)();
@@ -169,9 +179,11 @@ async function publish() {
         (0, ui_1.ok)('This version is already published');
     }
     else {
-        (0, ui_1.ok)(`Version ${result.deploy_id} published: visitors see it now`);
+        (0, ui_1.ok)(`Version ${result.deploy_id} published: visitors see its pages now`);
     }
     (0, ui_1.out)(result.project_url);
+    (0, ui_1.note)((0, ui_1.dim)('  Publishing moves the pages only. Cloud functions are one per project: visitors'));
+    (0, ui_1.note)((0, ui_1.dim)('  have been running the code of the last xflow deploy since it finished'));
 }
 async function rollback(args) {
     const { root, config } = (0, config_1.requireProject)();
@@ -181,12 +193,15 @@ async function rollback(args) {
     }
     const client = await (0, session_1.connectProject)(root, config);
     const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/rollback`, { method: 'POST', body: { deploy_id: deployId } });
-    (0, ui_1.ok)(`The dev version of the project is switched to ${result.deploy_id}`);
+    (0, ui_1.ok)(`The project now serves the pages of build ${result.deploy_id}`);
     (0, ui_1.out)(result.project_url);
+    (0, ui_1.note)((0, ui_1.dim)('  Only the pages came back. Cloud functions and the database are one per project:'));
+    (0, ui_1.note)((0, ui_1.dim)('  they are not versioned and stay as they are now'));
     if (result.revision !== null) {
-        (0, ui_1.note)((0, ui_1.dim)(`  The code of this version: xflow pull --revision ${result.revision} --into ./v${result.deploy_id}`));
+        (0, ui_1.note)((0, ui_1.dim)(`  The code of this build: xflow pull --revision ${result.revision} --into ../v${result.deploy_id}`));
+        (0, ui_1.note)((0, ui_1.dim)('  Building that code over the current one is a separate step: it overwrites the server revision'));
     }
-    (0, ui_1.note)((0, ui_1.dim)('  Visitors see it only after xflow publish'));
+    (0, ui_1.note)((0, ui_1.dim)('  Visitors see these pages only after xflow publish'));
 }
 async function deployments() {
     const { root, config } = (0, config_1.requireProject)();
@@ -203,4 +218,6 @@ async function deployments() {
         (0, ui_1.formatAge)(d.deployed_at ?? d.created_at),
         [d.is_dev ? (0, ui_1.bold)('dev') : '', d.is_live ? (0, ui_1.bold)('live') : ''].filter(Boolean).join(' '),
     ]));
+    (0, ui_1.note)((0, ui_1.dim)('  Serve the pages of an earlier build: xflow rollback <number>'));
+    (0, ui_1.note)((0, ui_1.dim)('  Fetch the code of a build: xflow pull --revision <its revision> --into ../copy'));
 }

package/dist/commands/sources.js

@@ -66,7 +66,7 @@ async function confirmForce(client, projectId, server, local) {
         (0, ui_1.warn)('Could not read the server copy: the list of disappearing files is unavailable');
     }
     (0, ui_1.note)('');
-    const confirmed = await (0, ui_1.confirmWord)(`This overwrites work that is not yours, with no way to recover it from the platform.`, card.name);
+    const confirmed = await (0, ui_1.confirmWord)(`The server revision will be replaced by the contents of this folder. Anything newer on the platform goes away, and it cannot be recovered from here.`, card.name);
     if (!confirmed)
         throw new errors_1.CliError('Cancelled');
 }
@@ -175,9 +175,12 @@ async function status() {
     const client = await (0, session_1.connectProject)(root, config);
     const tree = prepareTree(root, config);
     const state = (0, config_1.readState)(root);
-    const [card, server] = await Promise.all([
+    const [card, server, history] = await Promise.all([
         (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}`),
         latestRevision(client, config.projectId),
+        // History only decorates the output, so its failure must not take the command
+        // down with it: without it the line below simply says less.
+        (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/deployments`).catch(() => ({ deployments: [] })),
     ]);
     (0, ui_1.out)(`${(0, ui_1.bold)(card.name)}  ${(0, ui_1.dim)(card.id)}`);
     (0, ui_1.out)('');
@@ -200,9 +203,28 @@ async function status() {
             (0, ui_1.note)((0, ui_1.dim)('  Send and build them: xflow deploy'));
         }
     }
+    // Which revision the built version came from. Silent when there is nothing to say:
+    // the row fell out of the truncated history, it predates revisions, or a build is
+    // running right now and the answer would change in a minute.
+    const running = history.deployments.some((d) => ['pending', 'building', 'uploading'].includes(d.status));
+    const devRow = running ? null : (history.deployments.find((d) => d.is_dev) ?? null);
+    const builtFrom = devRow?.revision ?? null;
+    // The dev address holds a build that is not the newest one: the project was put back
+    // on earlier pages on purpose. Saying "the code is newer" here would name the wrong
+    // reason and send the developer to build what is already built.
+    const newest = history.deployments.find((d) => d.status === 'deployed');
+    const rolledBack = devRow?.status === 'deployed' && !!newest && newest.deploy_id !== devRow.deploy_id;
     (0, ui_1.out)('');
-    (0, ui_1.out)(`Built version:    ${card.dev_deploy_id ?? '(no build)'}`);
+    (0, ui_1.out)(`Built version:    ${card.dev_deploy_id ?? '(no build)'}` +
+        (builtFrom !== null ? ` from revision ${builtFrom}` : ''));
     (0, ui_1.out)(`Visitors see:     ${card.live_deploy_id ?? '(never published)'}`);
+    if (rolledBack) {
+        (0, ui_1.note)((0, ui_1.dim)('  The project serves the pages of an earlier build: a newer one is in the history'));
+        (0, ui_1.note)((0, ui_1.dim)('  Cloud functions and the database are not versioned and stay as they are'));
+    }
+    else if (builtFrom !== null && server && builtFrom < server.revision) {
+        (0, ui_1.note)((0, ui_1.dim)(`  The built version is behind the sources: revision ${builtFrom} against ${server.revision} on the server`));
+    }
     // Two different problems, two different fixes: an expiring token is renewed by
     // any build, a revoked one is not renewed by anything until a human reconnects
     // the account. Telling them apart saves a pointless rebuild.

package/dist/commands/storage.js

@@ -0,0 +1,370 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentTypeFor = contentTypeFor;
+exports.planBatches = planBatches;
+exports.caseCollisions = caseCollisions;
+exports.storageList = storageList;
+exports.storagePush = storagePush;
+exports.storageRemove = storageRemove;
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const node_stream_1 = require("node:stream");
+const api_1 = require("../api");
+const args_1 = require("../args");
+const config_1 = require("../config");
+const errors_1 = require("../errors");
+const session_1 = require("../session");
+const ui_1 = require("../ui");
+/**
+ * File storage of the project: the place for heavy static assets of the
+ * application.
+ *
+ * Sources are capped at 10 MB and are rebuilt on every deploy, so photos, video
+ * and PDFs do not belong there. Files here live beside the versions instead:
+ * they survive a build, they are metered against the plan of the organization,
+ * and their addresses do not change when the application is rebuilt.
+ */
+/** Files per batch, and bytes per batch: whichever comes first closes it. */
+const BATCH_FILES = 10;
+const BATCH_BYTES = 20 * 1024 * 1024;
+/** Uploads running at the same time. */
+const PARALLEL_UPLOADS = 4;
+/** Below this a file is sent as one buffer; above it, streamed off disk. */
+const STREAM_OVER_BYTES = 16 * 1024 * 1024;
+const UPLOAD_TIMEOUT_MS = 10 * 60_000;
+const CONTENT_TYPES = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.avif': 'image/avif',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.pdf': 'application/pdf',
+    '.json': 'application/json',
+    '.csv': 'text/csv',
+    '.txt': 'text/plain',
+    '.md': 'text/markdown',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.woff': 'font/woff',
+    '.woff2': 'font/woff2',
+    '.ttf': 'font/ttf',
+    '.otf': 'font/otf',
+    '.zip': 'application/zip',
+};
+/** Unknown extensions go up as bytes: the browser then trusts the file name. */
+function contentTypeFor(name) {
+    return CONTENT_TYPES[(0, node_path_1.extname)(name).toLowerCase()] ?? 'application/octet-stream';
+}
+/**
+ * Files of a directory, recursively.
+ *
+ * A walker of its own instead of the one the sources use: that one reads every
+ * file into memory to hash it and rewrites CRLF into LF for anything without a
+ * NUL byte early on, which would quietly damage SVG, CSV and subtitles on the
+ * way to the bucket. It also obeys .xflowignore, and a media folder is exactly
+ * what one is asked to put there so it stays out of the 10 MB archive.
+ *
+ * Dot entries and symlinks are skipped: pointing push at a working copy should
+ * not upload .git, and a link is not ours to follow.
+ */
+function collectMedia(root, prefix = '') {
+    const found = [];
+    for (const entry of (0, node_fs_1.readdirSync)(root, { withFileTypes: true })) {
+        if (entry.name.startsWith('.') || entry.isSymbolicLink())
+            continue;
+        if (entry.name === 'Thumbs.db')
+            continue;
+        const absolute = (0, node_path_1.join)(root, entry.name);
+        const remote = prefix ? `${prefix}/${entry.name}` : entry.name;
+        if (entry.isDirectory()) {
+            found.push(...collectMedia(absolute, remote));
+            continue;
+        }
+        if (!entry.isFile())
+            continue;
+        found.push({ absolute, remote, size: (0, node_fs_1.statSync)(absolute).size });
+    }
+    return found;
+}
+/**
+ * Split the upload into batches.
+ *
+ * The window where an object is in the bucket but not yet recorded lasts from
+ * the PUT to the confirm, and everything in that window is invisible to the
+ * project while still taking up the quota. Ten files or twenty megabytes keep
+ * the window that size no matter whether these are icons or video: a file
+ * heavier than the limit goes up alone.
+ */
+function planBatches(files, maxFiles = BATCH_FILES, maxBytes = BATCH_BYTES) {
+    const batches = [];
+    let batch = [];
+    let bytes = 0;
+    for (const file of files) {
+        if (batch.length > 0 && (batch.length >= maxFiles || bytes + file.size > maxBytes)) {
+            batches.push(batch);
+            batch = [];
+            bytes = 0;
+        }
+        batch.push(file);
+        bytes += file.size;
+    }
+    if (batch.length > 0)
+        batches.push(batch);
+    return batches;
+}
+/**
+ * Paths that differ only in case.
+ *
+ * The bucket tells them apart and Windows does not, so a folder that looks like
+ * one file locally becomes two files on the platform, and the application asks
+ * for whichever the code spells.
+ */
+function caseCollisions(files) {
+    const seen = new Map();
+    for (const file of files) {
+        const key = file.remote.toLowerCase();
+        seen.set(key, [...(seen.get(key) ?? []), file.remote]);
+    }
+    return [...seen.values()].filter((group) => group.length > 1);
+}
+async function fetchPage(client, projectId, params) {
+    const query = new URLSearchParams(params).toString();
+    return (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/storage?${query}`);
+}
+/** Everything under a folder, following the cursor to the end. */
+async function fetchAll(client, projectId, folder) {
+    const files = [];
+    let cursor = null;
+    do {
+        const params = { limit: '500' };
+        if (folder)
+            params.folder = folder;
+        if (cursor)
+            params.cursor = cursor;
+        const page = await fetchPage(client, projectId, params);
+        files.push(...page.files);
+        cursor = page.next_cursor;
+    } while (cursor);
+    return files;
+}
+async function storageList(args) {
+    const { config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    const folder = args.words[1] ?? '';
+    const files = await fetchAll(client, config.projectId, folder);
+    if ((0, args_1.flagBool)(args, 'json')) {
+        (0, ui_1.out)(JSON.stringify({ files }, null, 2));
+        return;
+    }
+    if (files.length === 0) {
+        (0, ui_1.note)(folder ? `No files under ${folder}` : 'The project has no files in storage');
+        (0, ui_1.note)((0, ui_1.dim)('  To upload a folder: xflow storage push ./media --to media'));
+        return;
+    }
+    (0, ui_1.table)(files.map((file) => [file.path, (0, ui_1.formatBytes)(file.size), file.url]));
+    (0, ui_1.note)((0, ui_1.dim)(`  ${files.length} file(s), ${(0, ui_1.formatBytes)(files.reduce((sum, f) => sum + f.size, 0))}`));
+}
+/** PUT the bytes straight into the bucket: they never pass through the platform. */
+async function putObject(file, ticket) {
+    const contentType = contentTypeFor(file.remote);
+    // Small files go as one buffer, big ones off the disk: 200 MB in memory is a
+    // price nothing here pays for.
+    const body = file.size > STREAM_OVER_BYTES
+        ? node_stream_1.Readable.toWeb((0, node_fs_1.createReadStream)(file.absolute))
+        : (0, node_fs_1.readFileSync)(file.absolute);
+    // `duplex` is required by Node to send a stream as a request body and is not
+    // in the type of fetch, hence the cast.
+    const init = {
+        method: 'PUT',
+        body,
+        headers: { 'Content-Type': contentType, 'Content-Length': String(file.size) },
+        signal: AbortSignal.timeout(UPLOAD_TIMEOUT_MS),
+        duplex: 'half',
+    };
+    const response = await fetch(ticket.upload_url, init);
+    if (!response.ok) {
+        throw new errors_1.CliError(`${file.remote}: the bucket rejected the upload (${response.status})`, 'Run the command again: what was uploaded before is kept');
+    }
+}
+/** Run tasks a few at a time, keeping the order of the results. */
+async function inParallel(items, limit, task) {
+    const results = new Array(items.length);
+    let next = 0;
+    async function worker() {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await task(items[index]);
+        }
+    }
+    await Promise.all(Array.from({ length: Math.min(limit, items.length) }, worker));
+    return results;
+}
+async function storagePush(args) {
+    const { config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    const source = args.words[1];
+    if (!source) {
+        throw new errors_1.CliError('A folder or a file is required', 'For example: xflow storage push ./media --to media');
+    }
+    const absolute = (0, node_path_1.resolve)(source);
+    let stat;
+    try {
+        stat = (0, node_fs_1.statSync)(absolute);
+    }
+    catch {
+        throw new errors_1.CliError(`No such file or folder: ${source}`);
+    }
+    const target = ((0, args_1.flagString)(args, 'to') ?? '').replace(/\\/g, '/').replace(/^\/+|\/+$/g, '');
+    const local = stat.isDirectory()
+        ? collectMedia(absolute)
+        : [{ absolute, remote: (0, node_path_1.basename)(absolute), size: stat.size }];
+    if (local.length === 0)
+        throw new errors_1.CliError(`Nothing to upload in ${source}`);
+    const files = local
+        .map((file) => ({ ...file, remote: target ? `${target}/${file.remote}` : file.remote }))
+        .sort((a, b) => a.remote.localeCompare(b.remote));
+    for (const group of caseCollisions(files)) {
+        (0, ui_1.warn)(`Names that differ only in case: ${group.join(', ')}`);
+        (0, ui_1.note)((0, ui_1.dim)('  The platform keeps them as separate files'));
+    }
+    const replace = (0, args_1.flagBool)(args, 'replace');
+    const asJson = (0, args_1.flagBool)(args, 'json');
+    // What is already there decides what to send: the same run repeated has to be
+    // cheap and quiet, not a pile of conflicts.
+    const known = new Map((await fetchAll(client, config.projectId, target)).map((f) => [f.path, f]));
+    const outcome = { uploaded: [], skipped: [], failed: [] };
+    const pending = [];
+    for (const file of files) {
+        const remote = known.get(file.remote);
+        if (!remote) {
+            pending.push(file);
+            continue;
+        }
+        if (remote.size === file.size) {
+            outcome.skipped.push({ path: file.remote, reason: 'already there' });
+            continue;
+        }
+        if (!replace) {
+            outcome.skipped.push({ path: file.remote, reason: 'differs, kept as is' });
+            continue;
+        }
+        pending.push(file);
+    }
+    if (pending.length === 0) {
+        report(outcome, asJson);
+        return;
+    }
+    const batches = planBatches(pending);
+    if (!asJson) {
+        const bytes = pending.reduce((sum, file) => sum + file.size, 0);
+        (0, ui_1.step)(`Uploading ${pending.length} file(s), ${(0, ui_1.formatBytes)(bytes)}`);
+    }
+    for (const batch of batches) {
+        const { files: tickets } = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/storage/upload-url`, {
+            method: 'POST',
+            body: {
+                files: batch.map((file) => ({
+                    path: file.remote,
+                    content_type: contentTypeFor(file.remote),
+                    size: file.size,
+                })),
+                overwrite: replace,
+            },
+        });
+        const byPath = new Map(tickets.map((ticket) => [ticket.path, ticket]));
+        const done = [];
+        const results = await inParallel(batch, PARALLEL_UPLOADS, async (file) => {
+            const ticket = byPath.get(file.remote);
+            if (!ticket)
+                return { file, error: 'the platform did not return an upload address' };
+            try {
+                await putObject(file, ticket);
+                return { file, ticket };
+            }
+            catch (e) {
+                return { file, error: e instanceof Error ? e.message : String(e) };
+            }
+        });
+        for (const result of results) {
+            if ('ticket' in result)
+                done.push({ file: result.file, ticket: result.ticket });
+            else
+                outcome.failed.push({ path: result.file.remote, reason: result.error });
+        }
+        if (done.length === 0)
+            continue;
+        // Confirm right after the batch, not at the end: an object that is in the
+        // bucket without a record is invisible to the project and still takes up
+        // the quota.
+        const confirmed = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/storage/confirm`, {
+            method: 'POST',
+            body: { files: done.map(({ ticket }) => ({ s3_key: ticket.s3_key })) },
+        });
+        outcome.uploaded.push(...confirmed.files.map((file) => ({ path: file.path, url: file.url, size: file.size })));
+        for (const failure of confirmed.failed) {
+            const owner = done.find(({ ticket }) => ticket.s3_key === failure.s3_key);
+            outcome.failed.push({ path: owner?.file.remote ?? failure.s3_key, reason: failure.error });
+        }
+    }
+    report(outcome, asJson);
+}
+function report(outcome, asJson) {
+    if (asJson) {
+        (0, ui_1.out)(JSON.stringify(outcome, null, 2));
+        return;
+    }
+    if (outcome.uploaded.length > 0) {
+        (0, ui_1.table)(outcome.uploaded.map((file) => [file.path, (0, ui_1.formatBytes)(file.size), file.url]));
+    }
+    const parts = [`uploaded ${outcome.uploaded.length}`];
+    if (outcome.skipped.length > 0)
+        parts.push(`skipped ${outcome.skipped.length}`);
+    if (outcome.failed.length > 0)
+        parts.push(`failed ${outcome.failed.length}`);
+    if (outcome.failed.length > 0) {
+        for (const file of outcome.failed)
+            (0, ui_1.warn)(`${file.path}: ${file.reason}`);
+        throw new errors_1.CliError(parts.join(', '), 'Run the command again: what went up is kept and skipped');
+    }
+    (0, ui_1.ok)(parts.join(', '));
+    if (outcome.uploaded.length > 0) {
+        (0, ui_1.note)((0, ui_1.dim)('  Addresses are permanent: replacing a file keeps its address'));
+        (0, ui_1.note)((0, ui_1.dim)('  The whole list in one piece: xflow storage ls --json'));
+    }
+}
+async function storageRemove(args) {
+    const { config } = (0, config_1.requireProject)();
+    const client = (0, session_1.connect)(config);
+    const folder = (0, args_1.flagString)(args, 'folder');
+    const url = args.words[1];
+    if ((!url && !folder) || (url && folder)) {
+        throw new errors_1.CliError('Either the address of a file or --folder is required', 'For example: xflow storage rm https://app.getxflow.com/api/storage/files/…/view, or xflow storage rm --folder photos --yes');
+    }
+    const query = new URLSearchParams(url ? { url } : { folder: folder });
+    if ((0, args_1.flagBool)(args, 'yes'))
+        query.set('confirm', 'true');
+    let result;
+    try {
+        result = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}/storage?${query.toString()}`, { method: 'DELETE' });
+    }
+    catch (e) {
+        // The platform counts what a folder holds and refuses until the answer is
+        // seen. Said in the words of this command, not of the API.
+        if (e instanceof api_1.ApiError && e.code === 'confirm_required') {
+            throw new errors_1.CliError(e.message, `To delete them anyway: xflow storage rm --folder ${folder} --yes`);
+        }
+        throw e;
+    }
+    (0, ui_1.ok)(`${(0, ui_1.bold)(String(result.deleted))} file(s) deleted`);
+    (0, ui_1.note)((0, ui_1.dim)('  There is no undo and no copy on the platform side'));
+}