@getxflow/cli 0.34.1 → 1.0.0

package/dist/commands/deploy.js

@@ -12,14 +12,14 @@ const config_1 = require("../config");
 const errors_1 = require("../errors");
 const prompt_1 = require("../prompt");
 const session_1 = require("../session");
-const template_1 = require("../template");
+const tree_1 = require("../tree");
 const ui_1 = require("../ui");
 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';
+const REMOVAL_IS_FINAL = 'Removal is final: the keys and schedules of those functions go with them';
 /** Print every check violation at once. */
 function reportIssues(e) {
     const issues = e.issues ?? [];
@@ -28,17 +28,16 @@ function reportIssues(e) {
         (0, ui_1.out)(`  ${(0, ui_1.bold)(issue.code)} ${where}`);
         (0, ui_1.note)((0, ui_1.dim)(`    ${issue.message}`));
     }
-    // Not the platform hint: it names its own JSON field, and a terminal has no field,
-    // it has the list printed right above.
+    // Not the platform hint: it names its own JSON field, and a terminal has the list printed above.
     throw new errors_1.CliError(e.message, 'Fix what is listed above and retry: the build did not start');
 }
 /** Poll the build until it finishes, printing phases. */
-async function waitForBuild(client, projectId, started) {
+async function waitForBuild(client, base, started) {
     const deadline = Date.now() + WAIT_LIMIT_MS;
     let shown = '';
     while (Date.now() < deadline) {
         await sleep(started.poll_after_ms || 3_000);
-        const build = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/builds/${started.deploy_id}`);
+        const build = await (0, api_1.apiJson)(client, `${base}/builds/${started.deploy_id}`);
         if (build.phase !== shown) {
             shown = build.phase;
             (0, ui_1.step)(build.phase_title);
@@ -46,35 +45,17 @@ async function waitForBuild(client, projectId, started) {
         if (build.phase === 'done' || build.phase === 'failed')
             return build;
     }
-    throw new errors_1.CliError('The build is taking longer than expected', `To check the state: xflow deployments. Version ${started.deploy_id}`);
+    throw new errors_1.CliError('The build is taking longer than expected', `To check the state: xflow deployments. Build ${started.deploy_id}`);
 }
 /**
- * Point the local .env at this project, function addresses included.
- *
- * The build bakes its own copy of the map into the bundle, this one is for
- * `npm run dev`: without it the local run calls a function that it has no
- * address for.
+ * Start the build, asking before anything is destroyed. Removing a cloud function
+ * cannot be undone, so the platform refuses such a deploy until the caller says yes,
+ * and the question is asked here, before it starts.
  */
-async function refreshPlatformEnv(root, client, projectId) {
-    const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
-    (0, template_1.writePlatformEnv)(root, card.project_token, client.apiUrl, card.functions, card.function_map);
-    return card.functions.filter((fn) => fn.invoke_url);
-}
-/**
- * Start the build, asking before anything is destroyed.
- *
- * Removing a cloud function cannot be undone: one created again later gets a
- * different address, and its schedules go with it. The platform therefore
- * refuses such a build until the caller says yes, and the question is asked
- * here, before the build starts, rather than reported once it already has.
- */
-async function startBuild(client, projectId, revision, allowRemovals, comment) {
-    const path = `/api/v1/projects/${projectId}/builds`;
+async function startBuild(client, base, revision, allowRemovals, comment) {
+    const path = `${base}/builds`;
     try {
-        return await (0, api_1.apiJson)(client, path, {
-            method: 'POST',
-            body: { revision, allow_removals: allowRemovals, comment },
-        });
+        return await (0, api_1.apiJson)(client, path, { method: 'POST', body: { revision, allow_removals: allowRemovals, comment } });
     }
     catch (e) {
         if (e instanceof api_1.ApiError && e.issues?.length)
@@ -84,251 +65,224 @@ async function startBuild(client, projectId, revision, allowRemovals, comment) {
         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.
+        // No terminal (CI, an agent): the flag is the only way to say yes.
         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');
+            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.warn)(`Gone from the sources, the deploy would remove them: ${removing.join(', ')}`);
         (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(', ') },
+            { label: 'Yes, remove and deploy', hint: removing.join(', ') },
         ]);
         if (answer !== 1)
-            throw new errors_1.CliError('The build did not start', 'Nothing was removed');
-        return (0, api_1.apiJson)(client, path, {
-            method: 'POST',
-            body: { revision, allow_removals: true, comment },
-        });
+            throw new errors_1.CliError('The deploy did not start', 'Nothing was removed');
+        return (0, api_1.apiJson)(client, path, { method: 'POST', body: { revision, allow_removals: true, comment } });
     }
 }
-/**
- * Ask whether the plan allows a build before the sources go up.
- *
- * The gate sits on the build itself, so a refusal used to arrive after the archive
- * had already become a revision, leaving the project looking like a forgotten
- * deploy. Same gate, same wording, one round trip earlier. A platform older than
- * this CLI answers the plain build state instead, and the deploy carries on as
- * before: the check is an improvement, not a requirement.
- */
-async function assertBuildAllowed(client, projectId) {
-    await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/builds?check=plan`);
-}
-/** Keep in sync with the builds route on the platform. */
+/** Keep in sync with lib/version-comment.ts on the platform. */
 const MAX_COMMENT_LENGTH = 200;
 /** Control and bidi-override characters: they spoof terminals, not comments. */
 const COMMENT_CONTROL_CHARS = /[\u0000-\u001f\u007f-\u009f\u200e\u200f\u202a-\u202e\u2066-\u2069]/g;
 /** The version comment as typed after -m, cleaned; empty when there is none. Pages take the same. */
 function versionComment(raw) {
-    const comment = (raw ?? '')
-        .replace(/\s+/g, ' ')
-        .replace(COMMENT_CONTROL_CHARS, '')
-        .trim();
+    const comment = (raw ?? '').replace(/\s+/g, ' ').replace(COMMENT_CONTROL_CHARS, '').trim();
     if (comment.length > MAX_COMMENT_LENGTH) {
         throw new errors_1.CliError(`The version comment is too long: ${MAX_COMMENT_LENGTH} characters at most`, 'One short line about what changed in this version is enough');
     }
     return comment;
 }
-/**
- * The version comment, checked before anything goes up: a refusal after the push
- * would leave the project with a revision newer than its build for no good reason.
- */
+/** Checked before anything goes up: a refusal after the push would leave a revision newer than its build. */
 function requireComment(args) {
     const comment = versionComment((0, args_1.flagString)(args, 'message'));
     if (!comment) {
-        throw new errors_1.CliError('Every version needs a comment saying what changed in it', 'Add -m: xflow deploy -m "Cart and card payments". One short line, written in the language the user speaks: it names this version in the history');
+        throw new errors_1.CliError('Every version needs a comment saying what changed in it', 'Add -m: xflow deploy apps/shop -m "Cart and card payments". One short line, written in the language the user speaks: it names this version in the history');
     }
     return comment;
 }
 /**
- * Everything after the build has started: the same for a build of the sources
- * just sent and for a rebuild of a revision the platform already holds.
- *
- * `root` is the folder to point at this project afterwards, and null when there
- * is none: a build asked for by id has no .env to refresh.
+ * The revision named by --revision. Pure and read first: a wrong number or a flag
+ * that cannot apply is worth saying before the version comment is asked for.
  */
-async function finishBuild(client, projectId, started, root) {
-    if (started.removed_functions?.length) {
-        (0, ui_1.warn)(`Removed from the cloud, gone from the sources: ${started.removed_functions.join(', ')}`);
+function statedRevision(revision, force) {
+    if (revision === undefined)
+        return undefined;
+    if (revision < 1) {
+        throw new errors_1.CliError(`--revision takes a revision number, got "${revision}"`, 'The revision of each build: xflow deployments');
     }
-    if (started.revoked_connections?.length) {
-        (0, ui_1.warn)(`Access revoked by the provider: ${started.revoked_connections.join(', ')}`);
-        (0, ui_1.note)((0, ui_1.dim)('  Reconnect the account in the platform settings: another build will not fix this'));
+    if (force) {
+        throw new errors_1.CliError('--force does not apply to --revision', 'Nothing is sent: the build runs the sources the platform already holds');
     }
-    if (started.shadowed_functions?.length) {
-        (0, ui_1.warn)(`Named like a standalone function of the organization: ${started.shadowed_functions.join(', ')}`);
-        (0, ui_1.note)((0, ui_1.dim)('  The app calls its own function under that name. Rename one of them to call the shared one'));
+    return revision;
+}
+/** The lines the functions deploy writes about what the internet can reach now. */
+function openLines(log) {
+    return (log ?? '').split('\n').filter((line) => /^(Open to the whole internet|Newly open)/.test(line));
+}
+function printNotes(started) {
+    for (const item of started.notes ?? []) {
+        (0, ui_1.note)(`  Unfinished: ${item.message}${item.file ? (0, ui_1.dim)(` (${item.file})`) : ''}`);
     }
-    const build = await waitForBuild(client, projectId, started);
-    if (build.phase === 'failed') {
-        if (build.log_tail) {
-            (0, ui_1.out)();
-            (0, ui_1.out)(build.log_tail);
-        }
-        throw new errors_1.CliError(build.error || 'The build failed', `Fix the code and try again: xflow deploy. Version ${build.deploy_id}`);
+}
+async function finishFunctions(client, base, started) {
+    printNotes(started);
+    const build = await waitForBuild(client, base, started);
+    if (build.phase === 'failed')
+        failed(build, 'xflow deploy functions');
+    (0, ui_1.ok)(`Functions deployed from revision ${build.revision} in ${build.elapsed_s} s`);
+    for (const line of openLines(build.log_tail))
+        (0, ui_1.warn)(line);
+    (0, ui_1.note)((0, ui_1.dim)('  Every app of the project calls the new code already: there is no publish step for functions'));
+}
+async function finishApp(client, base, started) {
+    printNotes(started);
+    const build = await waitForBuild(client, base, started);
+    if (build.phase === 'failed')
+        failed(build, 'xflow deploy');
+    (0, ui_1.ok)(`Build ${build.deploy_id} from revision ${build.revision} in ${build.elapsed_s} s`);
+    const card = await (0, api_1.apiJson)(client, base).catch(() => null);
+    if (card?.live?.deploy_id === build.deploy_id) {
+        (0, ui_1.ok)('Published: visitors see it now');
+        (0, ui_1.out)(card.url);
     }
-    (0, ui_1.ok)(`Version ${build.deploy_id} built from revision ${build.revision} in ${build.elapsed_s} s`);
-    (0, ui_1.out)(build.project_url);
-    // The functions were shipped by the build itself, so their addresses are known
-    // only now. A failure here does not undo a finished build: warn and stop there.
-    let functions = null;
-    if (root !== null) {
-        try {
-            functions = await refreshPlatformEnv(root, client, projectId);
-        }
-        catch {
-            (0, ui_1.warn)('Could not refresh the function addresses in .env, the build itself is fine');
-        }
+    else {
+        if (card)
+            (0, ui_1.out)(card.url);
+        (0, ui_1.note)((0, ui_1.dim)('  Visitors still see the previous build. Show this one: xflow publish'));
     }
-    // A project without a site has no pages to publish, and its functions went live
-    // with this very build. Naming publish there sends the reader to a refusal.
-    const hasSite = started.has_site !== false;
-    if (functions === null) {
-        (0, ui_1.note)((0, ui_1.dim)('  The cloud functions of this build are already live'));
-        if (hasSite)
-            (0, ui_1.note)((0, ui_1.dim)('  Publishing does not hold them back'));
+}
+function failed(build, retry) {
+    if (build.log_tail) {
+        (0, ui_1.out)();
+        (0, ui_1.out)(build.log_tail);
     }
-    else if (functions.length > 0) {
-        (0, ui_1.note)((0, ui_1.dim)(`  Cloud functions live now: ${functions.map((fn) => fn.name).join(', ')}`));
-        if (hasSite)
-            (0, ui_1.note)((0, ui_1.dim)('  There is one copy per project, publishing does not hold them back'));
+    throw new errors_1.CliError(build.error || 'The build failed', `Fix the code and try again: ${retry}. Build ${build.deploy_id}`);
+}
+/** An app deploy with root changes nobody deployed: the app may call code that is not in the cloud yet. */
+async function warnUndeployedRoot(client, projectRoot, projectId) {
+    try {
+        const tree = (0, sources_1.prepareTree)({ kind: 'project', root: projectRoot, projectId });
+        const server = await (0, sources_1.latestRevision)(client, `/api/v1/projects/${projectId}`);
+        const relation = server ? (0, tree_1.syncState)(tree.hash, server.tree_hash, (0, config_1.readState)(projectRoot).treeHash) : 'local-changes';
+        if (relation !== 'matches') {
+            (0, ui_1.warn)('The project root holds changes nobody deployed (functions, migrations or callers)');
+            (0, ui_1.note)((0, ui_1.dim)('  If this app needs them: xflow db migrate and xflow deploy functions first'));
+        }
     }
-    // An open function is called by its address and by nothing else: a page holds it
-    // in its own files. Printing it here saves the xflow functions list that every
-    // page needed anyway, and says out loud which functions this build left open.
-    const open = functions?.filter((fn) => fn.is_public) ?? [];
-    if (open.length > 0) {
-        (0, ui_1.note)((0, ui_1.dim)('  Open to anyone, no pass and no key, called at this address:'));
-        for (const fn of open)
-            (0, ui_1.note)((0, ui_1.dim)(`    ${fn.name}  ${fn.invoke_url}`));
+    catch {
+        // Only a hint: a root that cannot be read must not stop the app deploy.
     }
-    if (hasSite)
-        (0, ui_1.note)((0, ui_1.dim)('  Show the new pages to visitors: xflow publish'));
 }
-/**
- * Build a revision the platform already holds: this is how a version comes back.
- *
- * The sources of revision N are on the server, so nothing goes up and no copy of
- * them is needed next to the caller. That also means `--force` has nothing to
- * force: the revision on the server stays the newest one, and this build simply
- * runs an older one. The project can therefore be named by id, which is the only
- * way to bring back the version of a standalone function: its folder may live on
- * another machine entirely, and there is nothing else to roll back with, because
- * a project without a site has no pages to return.
- */
-async function deployRevision(args, revision, comment) {
-    const { projectId, client, root } = await (0, session_1.projectTarget)(args);
-    await assertBuildAllowed(client, projectId);
-    (0, ui_1.step)(`Building on the platform from revision ${revision}`);
-    const started = await startBuild(client, projectId, revision, (0, args_1.flagBool)(args, 'allow-removals'), comment);
-    await finishBuild(client, projectId, started, root);
+function targetsHint(projectRoot) {
+    const apps = (0, config_1.localApps)(projectRoot).map((app) => `xflow deploy ${config_1.APPS_DIR}/${app.folder}`);
+    return ['xflow deploy functions', ...apps].join(', ');
 }
-/**
- * The revision named by --revision, with the two rules that guard such a build.
- *
- * Kept pure and read before anything else: a wrong number or a flag that cannot
- * apply is worth saying before the version comment is asked for, and a rule like
- * this deserves a test that needs no platform to talk to.
- */
-function statedRevision(revision, force) {
-    if (revision === undefined)
-        return undefined;
-    // flagNumber already refuses anything but a whole number, so zero is what is
-    // left to catch here: revisions are counted from one.
-    if (revision < 1) {
-        throw new errors_1.CliError(`--revision takes a revision number, got "${revision}"`, 'The revision of each version: xflow deployments');
+async function deployTarget(target, args, comment, revision) {
+    const base = (0, sources_1.streamPath)(target);
+    const { client } = target;
+    if (revision === undefined) {
+        if (!target.root)
+            throw new errors_1.CliError('Nothing to send without a folder', 'Build a revision the platform holds: --revision <n>');
+        await (0, api_1.apiJson)(client, `${base}/builds?check=plan`);
+        if (target.kind === 'app' && target.projectRoot)
+            await warnUndeployedRoot(client, target.projectRoot, target.projectId);
+        if ((0, args_1.flagBool)(args, 'no-push')) {
+            const server = await (0, sources_1.latestRevision)(client, base);
+            if (!server)
+                throw new errors_1.CliError('The server holds no sources', 'Repeat without --no-push, so that the sources go up first');
+            revision = server.revision;
+            (0, ui_1.warn)(`Sources not sent (--no-push), the build runs from revision ${revision}`);
+        }
+        else {
+            const stream = target.kind === 'app'
+                ? { kind: 'app', root: target.root, appId: target.appId }
+                : { kind: 'project', root: target.root, projectId: target.projectId };
+            revision = (await (0, sources_1.pushSources)(stream, client, { force: (0, args_1.flagBool)(args, 'force') })).revision;
+        }
     }
-    if (force) {
-        throw new errors_1.CliError('--force does not apply to --revision', 'Nothing is sent: the build runs the sources the platform already holds');
+    (0, ui_1.step)(target.kind === 'app' ? `Building the app from revision ${revision}` : `Deploying the functions from revision ${revision}`);
+    const started = await startBuild(client, base, revision, (0, args_1.flagBool)(args, 'allow-removals'), comment);
+    if (started.removed_functions?.length)
+        (0, ui_1.warn)(`Removed from the cloud, gone from the sources: ${started.removed_functions.join(', ')}`);
+    if (started.revoked_connections?.length) {
+        (0, ui_1.warn)(`Access revoked by the provider: ${started.revoked_connections.join(', ')}`);
+        (0, ui_1.note)((0, ui_1.dim)('  Reconnect the account in the platform settings: another deploy will not fix this'));
     }
-    return revision;
+    if (target.kind === 'app')
+        await finishApp(client, base, started);
+    else
+        await finishFunctions(client, base, started);
 }
 async function deploy(args) {
     const stated = statedRevision((0, args_1.flagNumber)(args, 'revision'), (0, args_1.flagBool)(args, 'force'));
     const comment = requireComment(args);
-    if (stated !== undefined)
-        return deployRevision(args, stated, comment);
-    if ((0, args_1.flagString)(args, 'project') !== undefined) {
-        throw new errors_1.CliError('xflow deploy sends the sources next to it, so it runs in the project folder', 'Name a project by id only to build a revision it already has: xflow deploy --project <id> --revision <n> -m "what came back"');
+    const word = args.words[0];
+    const byId = (0, args_1.flagString)(args, 'project') !== undefined || (0, args_1.flagString)(args, 'app') !== undefined;
+    if (byId && stated === undefined) {
+        throw new errors_1.CliError('xflow deploy sends the sources next to it, so it runs in the project folder', 'Name one by id only to build a revision it already has: --project <id> --revision <n> (functions) or --app <id> --revision <n>');
     }
-    const { root, config } = (0, config_1.requireProject)();
-    const client = await (0, session_1.connectProject)(config.projectId, root, config);
-    let revision;
-    if ((0, args_1.flagBool)(args, 'no-push')) {
-        const server = await (0, sources_1.latestRevision)(client, config.projectId);
-        if (!server) {
-            throw new errors_1.CliError('The server holds no sources', 'Repeat without --no-push, so that the sources go up first');
+    // In the project root a bare deploy would hide what changes for every app: name the target.
+    if (!byId && word === undefined) {
+        const { root, appRoot } = (0, config_1.requireProject)();
+        if (!appRoot) {
+            throw new errors_1.CliError('Name what to deploy: the functions or one app', `From here: ${targetsHint(root)}`);
         }
-        revision = server.revision;
-        (0, ui_1.warn)(`Sources not sent (--no-push), the build runs from revision ${revision}`);
-    }
-    else {
-        await assertBuildAllowed(client, config.projectId);
-        revision = (await (0, sources_1.pushSources)(root, config, client, { force: (0, args_1.flagBool)(args, 'force') })).revision;
     }
-    (0, ui_1.step)(`Building on the platform from revision ${revision}`);
-    const started = await startBuild(client, config.projectId, revision, (0, args_1.flagBool)(args, 'allow-removals'), comment);
-    await finishBuild(client, config.projectId, started, root);
+    await deployTarget(await (0, session_1.streamTarget)(args, word, false), args, comment, stated);
 }
 async function publish(args) {
-    const { projectId, client } = await (0, session_1.projectTarget)(args);
-    (0, ui_1.step)('Publishing the current dev version');
-    const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/publish`, { method: 'POST', timeoutMs: 120_000 });
-    if (result.already_published) {
-        (0, ui_1.ok)('This version is already published');
-    }
-    else {
-        (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'));
+    const target = await (0, session_1.appTarget)(args);
+    const deployId = args.words[0];
+    (0, ui_1.step)(deployId ? `Publishing build ${deployId}` : 'Publishing the newest build');
+    const result = await (0, api_1.apiJson)(target.client, `/api/v1/apps/${target.appId}/publish`, { method: 'POST', body: deployId ? { deploy_id: deployId } : {} });
+    if (result.already_live)
+        (0, ui_1.ok)(`Build ${result.deploy_id} is already live`);
+    else
+        (0, ui_1.ok)(`Build ${result.deploy_id} published: visitors see it now`);
+    (0, ui_1.out)(result.url);
+    (0, ui_1.note)((0, ui_1.dim)('  Only the app moved. Functions and the database are one per project: to bring back the'));
+    (0, ui_1.note)((0, ui_1.dim)('  functions of an earlier revision, xflow deploy functions --revision <n> (xflow deployments functions)'));
 }
+/** The same pointer move as publish, with the number required. */
 async function rollback(args) {
-    const deployId = args.words[0];
-    if (!deployId) {
-        throw new errors_1.CliError('A version number is required', 'To see the versions: xflow deployments. For example: xflow rollback 481203');
+    if (!args.words[0]) {
+        throw new errors_1.CliError('A build number is required', 'The builds: xflow deployments. For example: xflow rollback 481203');
     }
-    const { projectId, client } = await (0, session_1.projectTarget)(args);
-    const result = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/rollback`, { method: 'POST', body: { deploy_id: deployId } });
-    (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 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 these pages only after xflow publish'));
+    await publish(args);
+}
+function functionsTable(rows) {
+    (0, ui_1.table)(rows.map((d) => [
+        d.deploy_id ?? '-',
+        d.revision !== null ? `revision ${d.revision}` : 'no revision',
+        d.status === 'deployed' ? 'done' : d.status,
+        (0, ui_1.formatAge)(d.deployed_at ?? d.created_at),
+        d.kind === 'wrapper' ? 'platform: wrapper update' : shortComment(d.comment),
+    ]));
+    (0, ui_1.note)((0, ui_1.dim)('  Bring the functions of a revision back: xflow deploy functions --revision <n> -m "why"'));
+}
+function shortComment(comment) {
+    // Plain text only: a padded cell with ANSI codes would skew every column after it.
+    return comment && comment.length > 60 ? `${comment.slice(0, 59)}…` : (comment ?? '');
 }
 async function deployments(args) {
-    const { projectId, client } = await (0, session_1.projectTarget)(args);
-    const data = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}/deployments`);
+    const word = args.words[0];
+    const target = await (0, session_1.streamTarget)(args, word, word !== 'functions');
+    const data = await (0, api_1.apiJson)(target.client, `${(0, sources_1.streamPath)(target)}/deployments`);
     if (data.deployments.length === 0) {
-        (0, ui_1.note)('No versions yet. To build and release: xflow deploy');
+        (0, ui_1.note)(target.kind === 'app' ? 'No builds yet: xflow deploy' : 'No functions deploys yet: xflow deploy functions');
         return;
     }
+    if (target.kind === 'project')
+        return functionsTable(data.deployments);
     (0, ui_1.table)(data.deployments.map((d) => [
         d.deploy_id ?? '-',
         d.revision !== null ? `revision ${d.revision}` : 'no revision',
         d.status === 'deployed' ? 'ready' : d.status,
         (0, ui_1.formatAge)(d.deployed_at ?? d.created_at),
-        // Plain text only: a padded cell with ANSI codes would skew every column after it.
-        d.comment && d.comment.length > 60 ? `${d.comment.slice(0, 59)}…` : (d.comment ?? ''),
-        // pages_kept === false marks a build the storage cleanup has stripped:
-        // rollback refuses it, so saying so here saves the agent a call. Older
-        // platforms omit the field, and then the column stays as it was.
-        [
-            d.is_dev ? (0, ui_1.bold)('dev') : '',
-            d.is_live ? (0, ui_1.bold)('live') : '',
-            d.pages_kept === false ? 'no pages' : '',
-        ]
-            .filter(Boolean)
-            .join(' '),
+        shortComment(d.comment),
+        [d.is_live ? (0, ui_1.bold)('live') : '', d.status === 'deployed' && !d.pages_kept ? 'no pages' : ''].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)('  Pages live for the three latest builds; "no pages" marks the rest'));
-    (0, ui_1.note)((0, ui_1.dim)('  Fetch the code of a build: xflow pull --revision <its revision> --into ../copy'));
+    (0, ui_1.note)((0, ui_1.dim)('  Point the address at another build (that is the rollback): xflow publish <number>'));
+    (0, ui_1.note)((0, ui_1.dim)('  The files live for the three latest builds; "no pages" marks the rest'));
+    (0, ui_1.note)((0, ui_1.dim)('  The code of a build: xflow pull --revision <its revision> --into ../copy'));
 }

package/dist/commands/dev.js

@@ -2,54 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dev = dev;
 const node_os_1 = require("node:os");
-const api_1 = require("../api");
 const config_1 = require("../config");
 const errors_1 = require("../errors");
 const session_1 = require("../session");
 const spawn_1 = require("../spawn");
-const template_1 = require("../template");
-const ui_1 = require("../ui");
 /**
- * The local dev server, handed the key this CLI picks for the project. The template
- * proxy trades it for a pass on every function call, so which organization holds the
- * project is decided here, by the rule every other command follows.
+ * The local dev server of one app. The template proxy sends every /_fn/<name> call
+ * to the platform as this app with the key picked here, so the callers and access
+ * are the same as in production and nothing about functions lives on this machine.
  *
  * Answers with the exit code of the server.
  */
 async function dev() {
-    const { root, config } = (0, config_1.requireProject)();
+    const { root, config, appRoot } = (0, config_1.requireProject)();
+    if (!appRoot) {
+        throw new errors_1.CliError('xflow dev runs one app: stand in its folder', 'For example: cd apps/<folder> && xflow dev');
+    }
+    const { appId } = (0, config_1.readAppConfig)(appRoot);
     const client = await (0, session_1.connectProject)(config.projectId, root, config);
     const env = {
         ...process.env,
         XFLOW_TOKEN: client.token,
-        // The proxy sends the key to this address unchecked, and the environment beats
-        // .env: pinned here, the key goes only to the platform that issued it.
-        VITE_XFLOW_API_URL: (0, template_1.envApiUrl)(client.apiUrl),
+        // The proxy sends the key to this address unchecked: pinned here, it goes only
+        // to the platform that issued it.
+        XFLOW_API_URL: client.apiUrl,
+        XFLOW_APP_ID: appId,
     };
-    // .env only moves on link and deploy: a function someone else shipped, or a new
-    // project token, would reach this run only after one of them.
-    try {
-        const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}`);
-        Object.assign(env, (0, template_1.platformEnv)(card.project_token, client.apiUrl, card.functions, card.function_map));
-    }
-    catch (e) {
-        (0, ui_1.warn)(`The function addresses were not fetched (${e instanceof Error ? e.message : String(e)}): the ones in .env are used`);
-    }
-    // Ctrl+C reaches the server on its own; staying alive until it is gone is what
-    // hands its exit code back instead of leaving it to print over the prompt.
+    // Ctrl+C reaches the server on its own; staying alive until it is gone hands its exit code back.
     process.on('SIGINT', () => { });
     // Appended last, so it beats the --host of the dev script: the server holds the key
-    // of the project and answers this machine alone. By number, not by name: proxies of
-    // older templates cut the Host at ':' and so never match [::1].
-    const result = (0, spawn_1.run)('npm', ['run', 'dev', '--', '--host', '127.0.0.1'], {
-        stdio: 'inherit',
-        cwd: root,
-        env,
-    });
+    // and answers this machine alone.
+    const result = (0, spawn_1.run)('npm', ['run', 'dev', '--', '--host', '127.0.0.1'], { stdio: 'inherit', cwd: appRoot, env });
     if (result.error) {
         throw new errors_1.CliError(`Could not start npm run dev: ${result.error.message}`, 'npm ships with Node.js: check that npm works in this terminal');
     }
-    // Killed by a signal: the code a shell would report for it.
     const signal = result.signal ? node_os_1.constants.signals[result.signal] : 0;
     return result.status ?? 128 + signal;
 }

package/dist/commands/env.js

@@ -32,11 +32,14 @@ const OPAQUE_REFERENCE = /process\.env\b(?!\.[A-Z0-9_]+|\[['"][A-Z0-9_]+['"]\])/
 /** Set by the platform itself. */
 const PROVIDED = new Set([
     'XFLOW_PROJECT_ID',
-    'XFLOW_PROJECT_TOKEN',
     'XFLOW_PROJECT_SCHEMA',
+    'XFLOW_FUNCTION_ID',
     'XFLOW_FUNCTION_NAME',
+    'XFLOW_FN_URL',
     'XFLOW_API_URL',
     'XFLOW_SERVER_KEY',
+    'XFLOW_SCHEDULE_SECRET',
+    'XFLOW_AUTH_SECRET',
     'DATABASE_URL',
     'NODE_ENV',
 ]);
@@ -178,7 +181,7 @@ async function envSet(args) {
     // Values reach a function on its next deploy.
     const users = referencedByFunctions(root).needed.get(name);
     if (users && users.length > 0) {
-        (0, ui_1.note)((0, ui_1.dim)(`  For the value to arrive, run xflow deploy: it ships ${users.join(', ')} again`));
+        (0, ui_1.note)((0, ui_1.dim)(`  For the value to arrive, run xflow deploy functions: it ships ${users.join(', ')} again`));
     }
 }
 async function envRemove(args) {
@@ -192,5 +195,5 @@ async function envRemove(args) {
         return;
     }
     (0, ui_1.ok)(`${name} deleted`);
-    (0, ui_1.note)((0, ui_1.dim)('  Functions already deployed keep the value until their next deploy'));
+    (0, ui_1.note)((0, ui_1.dim)('  Functions already deployed keep the value until xflow deploy functions'));
 }