@getxflow/cli 0.34.2 → 1.0.0

package/dist/commands/sources.js

@@ -1,8 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.streamPath = streamPath;
+exports.prepareTree = prepareTree;
 exports.latestRevision = latestRevision;
 exports.pushSources = pushSources;
-exports.downloadRevision = downloadRevision;
+exports.appFolderName = appFolderName;
+exports.pullAppInto = pullAppInto;
+exports.appFoldersOf = appFoldersOf;
+exports.cloneProject = cloneProject;
 exports.pull = pull;
 exports.status = status;
 const node_fs_1 = require("node:fs");
@@ -17,14 +22,36 @@ const zip_1 = require("../zip");
 const ui_1 = require("../ui");
 /** Server cap, checked locally to fail before uploading. Keep in sync with the server. */
 const MAX_ARCHIVE_BYTES = 10 * 1024 * 1024;
-function prepareTree(root, config) {
-    const buildDir = config.build?.dir?.replace(/^\.\//, '').replace(/\/+$/, '');
-    const extra = [...(config.ignore ?? []), ...(buildDir ? [`${buildDir}/`] : [])];
-    const { files, skippedLinks } = (0, tree_1.collectFiles)(root, (0, tree_1.loadIgnoreRules)(root, extra));
+/** Where a stream lives on the platform: the same routes under two prefixes. */
+function streamPath(target) {
+    return target.kind === 'app' ? `/api/v1/apps/${target.appId}` : `/api/v1/projects/${target.projectId}`;
+}
+/**
+ * The files of a stream. An app sends its own folder. The project root sends
+ * everything but apps/, plus apps/<folder>/xflow.json: the callers of a function
+ * name app folders, and the platform finds their appId in those files.
+ */
+function prepareTree(stream) {
+    let extra;
+    let added = [];
+    if (stream.kind === 'app') {
+        const config = (0, config_1.readAppConfig)(stream.root);
+        const buildDir = config.build?.dir?.replace(/^\.\//, '').replace(/\/+$/, '');
+        extra = [...(config.ignore ?? []), ...(buildDir ? [`${buildDir}/`] : [])];
+    }
+    else {
+        extra = [...((0, config_1.readConfig)(stream.root).ignore ?? []), `/${config_1.APPS_DIR}/`];
+        added = (0, config_1.localApps)(stream.root).map((app) => ({
+            path: `${config_1.APPS_DIR}/${app.folder}/${config_1.CONFIG_FILE}`,
+            content: Buffer.from((0, node_fs_1.readFileSync)((0, node_path_1.join)(app.root, config_1.CONFIG_FILE), 'utf-8').replace(/\r\n/g, '\n'), 'utf-8'),
+        }));
+    }
+    const collected = (0, tree_1.collectFiles)(stream.root, (0, tree_1.loadIgnoreRules)(stream.root, extra));
+    const files = [...collected.files, ...added].sort((a, b) => (a.path < b.path ? -1 : a.path > b.path ? 1 : 0));
     if (files.length === 0) {
         throw new errors_1.CliError('The folder has no files to send', 'Check .xflowignore: everything may be excluded');
     }
-    for (const link of skippedLinks) {
+    for (const link of collected.skippedLinks) {
         (0, ui_1.warn)(`Skipped the link ${link}: symbolic links are not synchronized`);
     }
     const archive = (0, zip_1.zipCreate)(files);
@@ -37,17 +64,17 @@ function prepareTree(root, config) {
     }
     return { files, hash: (0, tree_1.treeHash)(files), archive };
 }
-async function latestRevision(client, projectId) {
-    const { revisions } = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/revisions`);
+async function latestRevision(client, base) {
+    const { revisions } = await (0, api_1.apiJson)(client, `${base}/revisions`);
     return revisions[0] ?? null;
 }
-/** Show what --force would overwrite and ask for confirmation. */
-async function confirmForce(client, projectId, server, local) {
-    const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
+/** Show what --force would overwrite and ask for confirmation by the name of the project or app. */
+async function confirmForce(client, base, server, local) {
+    const { name } = await (0, api_1.apiJson)(client, base);
     (0, ui_1.note)('');
     (0, ui_1.warn)(`The server holds revision ${server.revision} from ${(0, ui_1.formatAge)(server.created_at)}, ${server.file_count} files`);
     try {
-        const info = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/pull`);
+        const info = await (0, api_1.apiJson)(client, `${base}/pull`);
         const serverPaths = new Set((0, zip_1.dropDirectoryEntries)((0, zip_1.zipRead)(await (0, api_1.downloadUrl)(info.download_url))).map((e) => e.path));
         const localPaths = new Set(local.map((f) => f.path));
         const disappearing = [...serverPaths].filter((p) => !localPaths.has(p));
@@ -66,22 +93,20 @@ 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)(`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);
+    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.', name);
     if (!confirmed)
         throw new errors_1.CliError('Cancelled');
 }
-/** The first step of deploy: sources go up as a revision before the build. */
-async function pushSources(root, config, client, options) {
-    const tree = prepareTree(root, config);
-    const state = (0, config_1.readState)(root);
-    const server = await latestRevision(client, config.projectId);
+/** The first step of deploy: sources of one stream go up as a revision before the build. */
+async function pushSources(stream, client, options) {
+    const base = streamPath(stream);
+    const tree = prepareTree(stream);
+    const state = (0, config_1.readState)(stream.root);
+    const server = await latestRevision(client, base);
     if (server) {
         const relation = (0, tree_1.syncState)(tree.hash, server.tree_hash, state.treeHash);
         if (relation === 'matches') {
-            (0, config_1.writeState)(root, {
-                treeHash: server.tree_hash,
-                organizationId: client.organizationId ?? undefined,
-            });
+            (0, config_1.writeState)(stream.root, { treeHash: server.tree_hash });
             (0, ui_1.ok)(`No changes, revision ${server.revision}`);
             return { revision: server.revision, status: 'unchanged' };
         }
@@ -91,7 +116,7 @@ async function pushSources(root, config, client, options) {
                 'Fetch the server copy alongside and compare: xflow pull --into ./server-copy');
         }
         if (options.force) {
-            await confirmForce(client, config.projectId, server, tree.files);
+            await confirmForce(client, base, server, tree.files);
         }
         else if (relation === 'unrecorded') {
             (0, ui_1.warn)(`This folder has no record of the server revision: the code goes up on top of revision ${server.revision}`);
@@ -99,47 +124,36 @@ async function pushSources(root, config, client, options) {
     }
     (0, ui_1.step)(`Sending ${tree.files.length} files (${(0, ui_1.formatBytes)(tree.archive.length)})`);
     const headers = {};
-    // Just read from this project: the header only guards the gap until the upload lands.
     if (server)
         headers['X-Base-Revision'] = String(server.revision);
     if (options.force)
         headers['X-Force'] = 'true';
-    const result = await (0, api_1.apiUpload)(client, `/api/v1/projects/${config.projectId}/push`, tree.archive, headers);
-    (0, config_1.writeState)(root, {
-        treeHash: result.tree_hash,
-        organizationId: client.organizationId ?? undefined,
-    });
-    if (result.status === 'unchanged') {
+    const result = await (0, api_1.apiUpload)(client, `${base}/push`, tree.archive, headers);
+    (0, config_1.writeState)(stream.root, { treeHash: result.tree_hash });
+    if (result.status === 'unchanged')
         (0, ui_1.ok)(`No changes, revision ${result.revision}`);
-    }
-    else {
+    else
         (0, ui_1.ok)(`Revision ${result.revision}: ${result.file_count} files, ${(0, ui_1.formatBytes)(result.size_bytes)}`);
-    }
     return { revision: result.revision, status: result.status };
 }
 /**
- * Does the folder hold work of its own?
- *
- * Only sources count. What `xflow link` itself lays down (xflow.json, the agent
- * instructions, dot-files the platform or the editor keeps) is bookkeeping, and
- * counting it turned the documented way to clone a project into a dead end:
- * link wrote its files, and the pull that follows refused over them.
+ * Does the folder hold work of its own? Only sources count: what link lays down
+ * (xflow.json, agent instructions, dot-files) is bookkeeping. `skipApps`: the
+ * project root, whose apps/ is not part of its stream.
  */
-function hasContent(dir) {
+function hasContent(dir, skipApps) {
     if (!(0, node_fs_1.existsSync)(dir))
         return false;
-    return (0, node_fs_1.readdirSync)(dir).some((name) => !name.startsWith('.') && name !== config_1.CONFIG_FILE && name !== 'AGENTS.md');
+    return (0, node_fs_1.readdirSync)(dir).some((name) => !name.startsWith('.') && name !== config_1.CONFIG_FILE && name !== 'AGENTS.md' && !(skipApps && name === config_1.APPS_DIR));
 }
 /**
- * Write a server revision into `target`.
- *
- * Shared with `xflow link`: linking an empty folder and then being told the
- * folder is not empty for a pull is a dead end the platform can avoid by
- * fetching the sources itself.
+ * Write a server revision of a stream into `target`. `skipApps` leaves apps/ of the
+ * project root alone: every app has its own stream. The entries come back too, so
+ * a clone can read the app folders from the project revision.
  */
-async function downloadRevision(client, projectId, target, revision) {
-    const query = revision !== undefined ? `?revision=${revision}` : '';
-    const info = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/pull${query}`);
+async function downloadRevision(client, base, target, options = {}) {
+    const query = options.revision !== undefined ? `?revision=${options.revision}` : '';
+    const info = await (0, api_1.apiJson)(client, `${base}/pull${query}`);
     (0, ui_1.step)(`Downloading revision ${info.revision} (${(0, ui_1.formatBytes)(info.size_bytes)})`);
     const entries = (0, zip_1.zipRead)(await (0, api_1.downloadUrl)(info.download_url));
     const hash = (0, tree_1.treeHash)(entries.map((e) => ({ path: e.path, content: e.content })));
@@ -147,102 +161,186 @@ async function downloadRevision(client, projectId, target, revision) {
         (0, ui_1.warn)('The hash of the downloaded tree did not match the server one: the contents may have changed in transit');
     }
     (0, node_fs_1.mkdirSync)(target, { recursive: true });
-    // The hash above covers the archive as the server holds it; what lands on disk is the
-    // code, without the skill copies older revisions still carry.
-    const files = (0, zip_1.dropDirectoryEntries)(entries).filter((entry) => !(0, tree_1.isSkillCopy)(entry.path));
+    // The hash covers the archive as the server holds it; what lands on disk is the code,
+    // without the skill copies older revisions carry and without apps/ of the root.
+    const files = (0, zip_1.dropDirectoryEntries)(entries).filter((entry) => !(0, tree_1.isSkillCopy)(entry.path) && !(options.skipApps && entry.path.startsWith(`${config_1.APPS_DIR}/`)));
     for (const entry of files) {
         const path = (0, node_path_1.join)(target, entry.path);
         (0, node_fs_1.mkdirSync)((0, node_path_1.dirname)(path), { recursive: true });
         (0, node_fs_1.writeFileSync)(path, entry.content);
     }
-    return { info, files: files.length };
+    return { info, files: files.length, entries };
+}
+/** A folder name out of an app name: latin letters, digits and dashes, unique in apps/. */
+function appFolderName(name, taken, fallback) {
+    const base = name
+        .toLowerCase()
+        .replace(/[^a-z0-9-]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .slice(0, 40) || fallback;
+    let folder = base;
+    for (let n = 2; taken.has(folder); n++)
+        folder = `${base}-${n}`;
+    taken.add(folder);
+    return folder;
+}
+/** Pull the latest revision of one app into its folder and make sure its xflow.json names it. */
+async function pullAppInto(client, appId, root) {
+    try {
+        const { info, files } = await downloadRevision(client, `/api/v1/apps/${appId}`, root);
+        (0, config_1.writeState)(root, { treeHash: info.tree_hash });
+        (0, ui_1.ok)(`${root}: revision ${info.revision}, ${files} files`);
+    }
+    catch (e) {
+        if (!(e instanceof api_1.ApiError && e.status === 404))
+            throw e;
+        (0, node_fs_1.mkdirSync)(root, { recursive: true });
+        (0, ui_1.note)((0, ui_1.dim)(`  ${root}: the app has no sources yet`));
+    }
+    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(root, config_1.CONFIG_FILE)) || (0, config_1.configKind)(safeJson((0, node_path_1.join)(root, config_1.CONFIG_FILE))) !== 'app') {
+        (0, config_1.writeConfig)(root, { appId, build: { command: 'npm run build', dir: 'dist' } });
+    }
+}
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+}
+function safeJson(path) {
+    return (0, node_fs_1.existsSync)(path) ? parseJson((0, node_fs_1.readFileSync)(path, 'utf-8')) : undefined;
+}
+/** appId → folder, read from the apps/<folder>/xflow.json files a project revision carries. */
+function appFoldersOf(entries) {
+    const folders = new Map();
+    for (const entry of entries) {
+        const match = /^apps\/([^/]+)\/xflow\.json$/.exec(entry.path);
+        if (!match)
+            continue;
+        const parsed = parseJson(entry.content.toString('utf-8'));
+        if ((0, config_1.configKind)(parsed) === 'app')
+            folders.set(parsed.appId, match[1]);
+    }
+    return folders;
+}
+/**
+ * The whole project into `dir`: the root stream, then the newest revision of every
+ * app into apps/<folder>. The folder names come from the project revision itself
+ * (apps/<folder>/xflow.json names the appId), so a clone lays out as the original.
+ */
+async function cloneProject(client, card, dir) {
+    const folders = new Map();
+    try {
+        const { info, files, entries } = await downloadRevision(client, `/api/v1/projects/${card.id}`, dir, { skipApps: true });
+        (0, config_1.writeState)(dir, { treeHash: info.tree_hash });
+        (0, ui_1.ok)(`Project root: revision ${info.revision}, ${files} files`);
+        for (const [appId, folder] of appFoldersOf(entries))
+            folders.set(appId, folder);
+    }
+    catch (e) {
+        if (!(e instanceof api_1.ApiError && e.status === 404))
+            throw e;
+        (0, ui_1.note)((0, ui_1.dim)('  The project root has no sources yet'));
+    }
+    const taken = new Set(folders.values());
+    for (const app of card.apps) {
+        const folder = folders.get(app.id) ?? appFolderName(app.name, taken, `app-${app.id.slice(0, 6)}`);
+        await pullAppInto(client, app.id, (0, node_path_1.join)(dir, config_1.APPS_DIR, folder));
+    }
 }
 async function pull(args) {
-    const { root, config } = (0, config_1.requireProject)();
     const into = (0, args_1.flagString)(args, 'into');
-    const target = into ? (0, node_path_1.resolve)(into) : root;
-    const client = await (0, session_1.connectProject)(config.projectId, root, config);
-    if (hasContent(target) && !(0, args_1.flagBool)(args, 'force')) {
+    const word = args.words[0];
+    const { root, config, appRoot } = (0, config_1.requireProject)();
+    // In the project root, with nowhere named: the whole project goes next to it.
+    if (into && word === undefined && appRoot === null) {
+        const target = (0, node_path_1.resolve)(into);
+        if (hasContent(target, false) && !(0, args_1.flagBool)(args, 'force')) {
+            throw new errors_1.CliError(`The directory ${target} is not empty`, 'Pick an empty one, or overwrite it: --force');
+        }
+        const client = await (0, session_1.connectProject)(config.projectId, root, config);
+        await cloneProject(client, await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}`), target);
+        (0, ui_1.ok)(`The project is in ${target}`);
+        return;
+    }
+    const stream = await (0, session_1.folderTarget)(word, false);
+    const base = streamPath(stream);
+    if (!stream.root && !into)
+        throw new errors_1.CliError('This app has no folder here', 'Name one: xflow pull --into <dir>');
+    const target = into ? (0, node_path_1.resolve)(into) : stream.root;
+    if (hasContent(target, stream.kind === 'project' && !into) && !(0, args_1.flagBool)(args, 'force')) {
         throw new errors_1.CliError(`The directory ${target} is not empty`, 'The platform cannot merge changes, that is git work. Fetch the server copy alongside: ' +
             'xflow pull --into ./server-copy, or overwrite the folder completely: xflow pull --force');
     }
-    const { info, files } = await downloadRevision(client, config.projectId, target, (0, args_1.flagNumber)(args, 'revision'));
-    (0, config_1.writeState)(target, {
-        treeHash: info.tree_hash,
-        organizationId: client.organizationId ?? undefined,
+    const { info, files } = await downloadRevision(stream.client, base, target, {
+        revision: (0, args_1.flagNumber)(args, 'revision'),
+        skipApps: stream.kind === 'project',
     });
+    (0, config_1.writeState)(target, { treeHash: info.tree_hash });
     (0, ui_1.ok)(`Revision ${info.revision}: ${files} files in ${target}`);
 }
+/** One line on how a local tree stands against its stream on the server. */
+async function syncLine(client, stream, base) {
+    const tree = prepareTree(stream);
+    const server = await latestRevision(client, base);
+    if (!server)
+        return `${tree.files.length} files, nothing on the server yet`;
+    const relation = (0, tree_1.syncState)(tree.hash, server.tree_hash, (0, config_1.readState)(stream.root).treeHash);
+    const head = `revision ${server.revision} on the server (${(0, ui_1.formatAge)(server.created_at)})`;
+    if (relation === 'matches')
+        return `${head}, the folder matches`;
+    if (relation === 'diverged')
+        return `${head}, ${(0, ui_1.bold)('diverged')}: the server holds a version this folder has not seen`;
+    if (relation === 'unrecorded')
+        return `${head}, the folder differs and has no record of it`;
+    return `${head}, ${(0, ui_1.bold)('local changes')}`;
+}
+function versionsLine(card) {
+    const live = card.live ? `live ${card.live.deploy_id}` : 'never published';
+    const newer = card.newest && !card.published ? `, newer build ${card.newest.deploy_id} not published` : '';
+    const building = card.building ? `, building ${card.building.deploy_id}` : '';
+    return `${live}${newer}${building}`;
+}
+async function appStatus(client, appId, root) {
+    const card = await (0, api_1.apiJson)(client, `/api/v1/apps/${appId}`);
+    (0, ui_1.out)(`${(0, ui_1.bold)(card.name)}  ${(0, ui_1.dim)(card.id)}`);
+    (0, ui_1.out)(`Sources:  ${await syncLine(client, { kind: 'app', root, appId }, `/api/v1/apps/${appId}`)}`);
+    (0, ui_1.out)(`Versions: ${versionsLine(card)}`);
+    if (card.newest && !card.published)
+        (0, ui_1.note)((0, ui_1.dim)('  Show the newest build to visitors: xflow publish'));
+    (0, ui_1.out)('');
+    (0, ui_1.out)(card.url);
+}
 async function status() {
-    const { root, config } = (0, config_1.requireProject)();
+    const { root, config, appRoot } = (0, config_1.requireProject)();
     const client = await (0, session_1.connectProject)(config.projectId, root, config);
-    const tree = prepareTree(root, config);
-    const state = (0, config_1.readState)(root);
-    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: [] })),
-    ]);
+    if (appRoot)
+        return appStatus(client, (0, config_1.readAppConfig)(appRoot).appId, appRoot);
+    const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}`);
+    const local = (0, config_1.localApps)(root);
     (0, ui_1.out)(`${(0, ui_1.bold)(card.name)}  ${(0, ui_1.dim)(card.id)}`);
     (0, ui_1.out)('');
-    (0, ui_1.out)(`Local:      ${tree.files.length} files, ${(0, ui_1.formatBytes)(tree.archive.length)} archived`);
-    if (!server) {
-        (0, ui_1.out)('On the server: no sources yet');
-        (0, ui_1.note)((0, ui_1.dim)('  Send and build them: xflow deploy'));
-    }
-    else {
-        (0, ui_1.out)(`On the server: revision ${server.revision}, ${server.file_count} files, ${(0, ui_1.formatAge)(server.created_at)}`);
-        const relation = (0, tree_1.syncState)(tree.hash, server.tree_hash, state.treeHash);
-        if (relation === 'matches') {
-            (0, ui_1.out)('State: matches the server');
-        }
-        else if (relation === 'diverged') {
-            (0, ui_1.out)(`State: ${(0, ui_1.bold)('diverged')}, the server holds a version this folder has not seen`);
-            (0, ui_1.note)((0, ui_1.dim)('  Fetch the server copy alongside: xflow pull --into ./server-copy'));
-        }
-        else if (relation === 'unrecorded') {
-            (0, ui_1.out)(`State: ${(0, ui_1.bold)('differs')}, this folder has no record of the server revision`);
-            (0, ui_1.note)((0, ui_1.dim)(`  xflow deploy sends this code on top of revision ${server.revision}; to compare first: xflow pull --into ./server-copy`));
-        }
-        else {
-            (0, ui_1.out)(`State: ${(0, ui_1.bold)('local changes')}`);
-            (0, ui_1.note)((0, ui_1.dim)('  Send and build them: xflow deploy'));
-        }
+    (0, ui_1.out)(`Project root (functions, migrations): ${await syncLine(client, { kind: 'project', root, projectId: card.id }, `/api/v1/projects/${card.id}`)}`);
+    for (const app of card.apps) {
+        const folder = local.find((item) => item.appId === app.id);
+        const appCard = await (0, api_1.apiJson)(client, `/api/v1/apps/${app.id}`);
+        (0, ui_1.out)('');
+        (0, ui_1.out)(`${(0, ui_1.bold)(folder ? `${config_1.APPS_DIR}/${folder.folder}` : app.name)}  ${app.url}`);
+        (0, ui_1.out)(`  Sources:  ${folder ? await syncLine(client, { kind: 'app', root: folder.root, appId: app.id }, `/api/v1/apps/${app.id}`) : 'no folder here (xflow pull --into, or xflow link in an empty folder)'}`);
+        (0, ui_1.out)(`  Versions: ${versionsLine(appCard)}`);
     }
-    // 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)'}` +
-        (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.
+    if (card.apps.length === 0)
+        (0, ui_1.note)((0, ui_1.dim)('  No apps: the functions are workflows. Add one: xflow apps add <folder>'));
+    // An expiring token is renewed by any deploy of the functions, a revoked one only by a human.
     const ailing = (card.connections ?? []).filter((c) => c.health !== 'ok');
     if (ailing.length > 0) {
         (0, ui_1.out)('');
         (0, ui_1.out)((0, ui_1.bold)('Connected accounts needing attention:'));
         for (const connection of ailing) {
             const problem = connection.health === 'expiring'
-                ? `expires in ${connection.days_left} days, any build renews it`
+                ? `expires in ${connection.days_left} days, xflow deploy functions renews it`
                 : connection.health === 'expired'
                     ? 'access has expired, reconnect the account in the platform settings'
                     : 'access was revoked by the provider, reconnect the account in the platform settings';

package/dist/commands/storage.js

@@ -336,7 +336,7 @@ function report(outcome, asJson) {
     }
     (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)('  Use the address as is inside an app: it is relative to the app host and permanent'));
         (0, ui_1.note)((0, ui_1.dim)('  The whole list in one piece: xflow storage ls --json'));
     }
 }
@@ -344,7 +344,7 @@ async function storageRemove(args) {
     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');
+        throw new errors_1.CliError('Either the address of a file or --folder is required', 'For example: xflow storage rm /_files/<id>, or xflow storage rm --folder photos --yes');
     }
     const query = new URLSearchParams(url ? { url } : { folder: folder });
     if ((0, args_1.flagBool)(args, 'yes'))

package/dist/config.js

@@ -1,11 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigError = exports.CONFIG_FILE = void 0;
+exports.ConfigError = exports.APPS_DIR = exports.CONFIG_FILE = void 0;
+exports.configKind = configKind;
+exports.findRoots = findRoots;
 exports.findProjectRoot = findProjectRoot;
 exports.readConfig = readConfig;
+exports.readAppConfig = readAppConfig;
 exports.writeConfig = writeConfig;
 exports.localConfig = localConfig;
 exports.requireProject = requireProject;
+exports.localApps = localApps;
 exports.apiUrlFor = apiUrlFor;
 exports.readState = readState;
 exports.writeState = writeState;
@@ -14,60 +18,112 @@ const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
 const version_1 = require("./version");
 exports.CONFIG_FILE = 'xflow.json';
+exports.APPS_DIR = 'apps';
 const STATE_DIR = '.xflow';
 class ConfigError extends Error {
 }
 exports.ConfigError = ConfigError;
-/** Walk up from cwd. */
-function findProjectRoot(from = process.cwd()) {
+function readJson(path) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+/** Which of the two files this is; null when it is neither. */
+function configKind(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const { appId, projectId } = value;
+    if (typeof appId === 'string' && appId)
+        return 'app';
+    if (typeof projectId === 'string' && projectId)
+        return 'project';
+    return null;
+}
+/**
+ * Walk up: the first xflow.json with appId is the app folder, the one with
+ * projectId above it is the project. A file that is neither stops the walk as a
+ * project root, so readConfig can say what is wrong with it.
+ */
+function findRoots(from = process.cwd()) {
     let dir = (0, node_path_1.resolve)(from);
+    let appRoot = null;
     for (;;) {
-        if ((0, node_fs_1.existsSync)((0, node_path_1.join)(dir, exports.CONFIG_FILE)))
-            return dir;
+        const path = (0, node_path_1.join)(dir, exports.CONFIG_FILE);
+        if ((0, node_fs_1.existsSync)(path)) {
+            const kind = configKind(readJson(path));
+            if (kind === 'app')
+                appRoot ??= dir;
+            else
+                return { projectRoot: dir, appRoot };
+        }
         const parent = (0, node_path_1.dirname)(dir);
         if (parent === dir)
-            return null;
+            break;
         dir = parent;
     }
+    if (appRoot) {
+        throw new ConfigError(`This app folder is not inside its project: no ${exports.CONFIG_FILE} with projectId above ${appRoot}.\n` +
+            '  Clone the whole project: xflow link <project id> in an empty folder');
+    }
+    return null;
+}
+function findProjectRoot(from) {
+    return findRoots(from)?.projectRoot ?? null;
 }
 function readConfig(root) {
-    const path = (0, node_path_1.join)(root, exports.CONFIG_FILE);
-    let parsed;
-    try {
-        parsed = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
-    }
-    catch (e) {
-        throw new ConfigError(`Could not read ${exports.CONFIG_FILE}: ${e instanceof Error ? e.message : e}`);
-    }
-    const config = parsed;
-    if (!config || typeof config.projectId !== 'string' || !config.projectId) {
+    const parsed = readJson((0, node_path_1.join)(root, exports.CONFIG_FILE));
+    if (parsed === undefined)
+        throw new ConfigError(`Could not read ${(0, node_path_1.join)(root, exports.CONFIG_FILE)}: it is not JSON`);
+    if (configKind(parsed) !== 'project') {
         throw new ConfigError(`${exports.CONFIG_FILE} has no projectId. Link the folder to a project: xflow link <id>`);
     }
-    return config;
+    return parsed;
+}
+function readAppConfig(appRoot) {
+    const parsed = readJson((0, node_path_1.join)(appRoot, exports.CONFIG_FILE));
+    if (configKind(parsed) !== 'app') {
+        throw new ConfigError(`${(0, node_path_1.join)(appRoot, exports.CONFIG_FILE)} has no appId. Apps are created with xflow apps add <folder>`);
+    }
+    return parsed;
 }
 function writeConfig(root, config) {
     (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, exports.CONFIG_FILE), `${JSON.stringify(config, null, 2)}\n`, 'utf-8');
 }
-/** The config of the folder we are in, when there is one and it parses. */
+/** The config of the project we are in, when there is one and it parses. */
 function localConfig() {
-    const root = findProjectRoot();
-    if (!root)
-        return undefined;
     try {
-        return readConfig(root);
+        const root = findProjectRoot();
+        return root ? readConfig(root) : undefined;
     }
     catch {
         return undefined;
     }
 }
 function requireProject() {
-    const root = findProjectRoot();
-    if (!root) {
-        throw new ConfigError(`The folder is not linked to a project: there is no ${exports.CONFIG_FILE} next to it.\n` +
+    const roots = findRoots();
+    if (!roots) {
+        throw new ConfigError(`The folder is not linked to a project: there is no ${exports.CONFIG_FILE} here or above.\n` +
             '  Link an existing one: xflow link <project id>\n' +
             '  Create a new one:     xflow init');
     }
-    return { root, config: readConfig(root) };
+    return { root: roots.projectRoot, config: readConfig(roots.projectRoot), appRoot: roots.appRoot };
+}
+/** The app folders of the project: apps/<folder>/xflow.json with an appId. */
+function localApps(projectRoot) {
+    const base = (0, node_path_1.join)(projectRoot, exports.APPS_DIR);
+    if (!(0, node_fs_1.existsSync)(base))
+        return [];
+    return (0, node_fs_1.readdirSync)(base, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory())
+        .flatMap((entry) => {
+        const root = (0, node_path_1.join)(base, entry.name);
+        const config = readJson((0, node_path_1.join)(root, exports.CONFIG_FILE));
+        return configKind(config) === 'app' ? [{ folder: entry.name, root, appId: config.appId }] : [];
+    })
+        .sort((a, b) => (a.folder < b.folder ? -1 : 1));
 }
 function apiUrlFor(config) {
     const raw = (process.env.XFLOW_API_URL?.trim() || config?.api?.trim() || version_1.DEFAULT_API_URL).replace(/\/+$/, '');