@getxflow/cli 0.15.0 → 0.17.0

package/dist/commands/deploy.js

@@ -4,8 +4,6 @@ exports.deploy = deploy;
 exports.publish = publish;
 exports.rollback = rollback;
 exports.deployments = deployments;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
 const api_1 = require("../api");
 const args_1 = require("../args");
 const config_1 = require("../config");
@@ -47,21 +45,15 @@ async function waitForBuild(client, projectId, started) {
     throw new errors_1.CliError('The build is taking longer than expected', `To check the state: xflow deployments. Version ${started.deploy_id}`);
 }
 /**
- * Write the function addresses into the local .env.
+ * 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.
  */
-async function refreshFunctionsEnv(root, client, projectId) {
+async function refreshPlatformEnv(root, client, projectId) {
     const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${projectId}`);
-    // No .env at all (fresh clone): recreate it fully, like link does.
-    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(root, '.env')) && card.project_token) {
-        (0, node_fs_1.writeFileSync)((0, node_path_1.join)(root, '.env'), (0, template_1.envFile)(card.project_token, client.apiUrl, card.functions), 'utf-8');
-    }
-    else {
-        (0, template_1.writeEnvValue)(root, template_1.FUNCTIONS_ENV_KEY, (0, template_1.functionsEnvValue)(card.functions));
-    }
+    (0, template_1.writePlatformEnv)(root, card.project_token, client.apiUrl, card.functions);
     return card.functions.filter((fn) => fn.invoke_url).map((fn) => fn.name);
 }
 /**
@@ -180,7 +172,7 @@ async function deploy(args) {
     // 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.
     try {
-        const functions = await refreshFunctionsEnv(root, client, config.projectId);
+        const functions = await refreshPlatformEnv(root, client, config.projectId);
         if (functions.length > 0) {
             (0, ui_1.note)((0, ui_1.dim)(`  Functions in .env: ${functions.join(', ')}`));
         }

package/dist/commands/functions.js

@@ -93,7 +93,7 @@ async function functionsInvoke(args) {
     const text = await response.text();
     (0, ui_1.note)((0, ui_1.dim)(`${response.status} ${response.statusText} in ${elapsed} ms`));
     if (text)
-        (0, ui_1.out)(prettyBody(text));
+        (0, ui_1.out)((0, args_1.flagBool)(args, 'json') ? text : prettyBody(text));
     if (!response.ok) {
         throw new errors_1.CliError(`The function answered ${response.status}`, `The stack and console output: xflow functions logs ${name}`);
     }

package/dist/commands/projects.js

@@ -77,7 +77,7 @@ async function init(args) {
             write(target, file.path, titleFromProject(file.path, file.content, name));
         for (const file of (0, template_1.scaffoldFiles)(name))
             write(target, file.path, file.content);
-        write(target, '.env', (0, template_1.envFile)(project.project_token ?? '', client.apiUrl));
+        (0, template_1.writePlatformEnv)(target, project.project_token, client.apiUrl);
         const config = {
             projectId: project.id,
             build: { command: 'npm run build', dir: 'dist' },
@@ -159,11 +159,8 @@ async function link(args) {
     (0, config_1.ignoreStateInGit)(dir);
     if (client.organizationId)
         (0, config_1.writeState)(dir, { organizationId: client.organizationId });
-    // A fresh clone has no .env: recreate it, never overwrite an existing one.
-    if (!(0, node_fs_1.existsSync)((0, node_path_1.join)(dir, '.env')) && card.project_token) {
-        write(dir, '.env', (0, template_1.envFile)(card.project_token, client.apiUrl, card.functions));
-        (0, ui_1.note)((0, ui_1.dim)('  Created .env with the project token and the function addresses'));
-    }
+    (0, template_1.writePlatformEnv)(dir, card.project_token, client.apiUrl, card.functions);
+    (0, ui_1.note)((0, ui_1.dim)('  .env now points at this project'));
     const skillReady = (0, skills_1.installSkillQuietly)(dir);
     (0, ui_1.ok)(`The folder is linked to the project "${card.name}"`);
     (0, ui_1.note)((0, ui_1.dim)(`  ${(0, node_path_1.join)(dir, config_1.CONFIG_FILE)}`));
@@ -176,7 +173,7 @@ async function link(args) {
     // compare against and stops.
     try {
         const { info, files } = await (0, sources_1.downloadRevision)(client, card.id, dir);
-        (0, config_1.writeState)(dir, { revision: info.revision, treeHash: info.tree_hash });
+        (0, config_1.writeState)(dir, { treeHash: info.tree_hash });
         (0, ui_1.ok)(`Revision ${info.revision}: ${files} files`);
     }
     catch (e) {

package/dist/commands/sources.js

@@ -74,33 +74,32 @@ async function confirmForce(client, projectId, server, local) {
 async function pushSources(root, config, client, options) {
     const tree = prepareTree(root, config);
     const state = (0, config_1.readState)(root);
-    (0, ui_1.step)(`Sending ${tree.files.length} files (${(0, ui_1.formatBytes)(tree.archive.length)})`);
     const server = await latestRevision(client, config.projectId);
-    // Unknown base revision (fresh clone): a matching hash just syncs,
-    // a mismatch must not overwrite silently.
-    if (server && state.revision === undefined && !options.force) {
-        if (server.tree_hash === tree.hash) {
-            (0, config_1.writeState)(root, {
-                revision: server.revision,
-                treeHash: server.tree_hash,
-                organizationId: client.organizationId ?? undefined,
-            });
-            (0, ui_1.ok)(`Already in sync, revision ${server.revision}`);
-            return { revision: server.revision, status: 'unchanged' };
-        }
-        throw new errors_1.CliError(`The server holds revision ${server.revision} while this folder does not remember which version it worked from`, 'Fetch the server copy alongside and compare: xflow pull --into ./server-copy');
+    if (server && server.tree_hash === tree.hash) {
+        (0, config_1.writeState)(root, {
+            treeHash: server.tree_hash,
+            organizationId: client.organizationId ?? undefined,
+        });
+        (0, ui_1.ok)(`No changes, revision ${server.revision}`);
+        return { revision: server.revision, status: 'unchanged' };
+    }
+    // Asked before the upload, so a doomed archive never leaves the machine.
+    if (server && server.tree_hash !== state.treeHash && !options.force) {
+        throw new errors_1.CliError(`The server holds revision ${server.revision}, and this folder does not stand on it`, 'Someone deployed before you, or this folder worked on a different project. ' +
+            'Fetch the server copy alongside and compare: xflow pull --into ./server-copy');
     }
     if (options.force && server && server.tree_hash !== tree.hash) {
         await confirmForce(client, config.projectId, server, tree.files);
     }
+    (0, ui_1.step)(`Sending ${tree.files.length} files (${(0, ui_1.formatBytes)(tree.archive.length)})`);
     const headers = {};
-    if (state.revision !== undefined)
-        headers['X-Base-Revision'] = String(state.revision);
+    // 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, {
-        revision: result.revision,
         treeHash: result.tree_hash,
         organizationId: client.organizationId ?? undefined,
     });
@@ -165,7 +164,6 @@ async function pull(args) {
     // Only the working folder tracks revisions; a side copy (--into) must not reset them.
     if (!into) {
         (0, config_1.writeState)(root, {
-            revision: info.revision,
             treeHash: info.tree_hash,
             organizationId: client.organizationId ?? undefined,
         });
@@ -196,8 +194,8 @@ async function status() {
         if (server.tree_hash === tree.hash) {
             (0, ui_1.out)('State: matches the server');
         }
-        else if (state.revision !== undefined && state.revision < server.revision) {
-            (0, ui_1.out)(`State: ${(0, ui_1.bold)('diverged')}, the server is newer (you worked from ${state.revision})`);
+        else if (server.tree_hash !== state.treeHash) {
+            (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 {

package/dist/config.js

@@ -82,7 +82,9 @@ function readState(root) {
     if (!(0, node_fs_1.existsSync)(path))
         return {};
     try {
-        return JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
+        // Read by field, so that keys older versions wrote leave the file on the next write.
+        const { treeHash, organizationId } = JSON.parse((0, node_fs_1.readFileSync)(path, 'utf-8'));
+        return { treeHash, organizationId };
     }
     catch {
         return {};

package/dist/flags.js

@@ -50,7 +50,7 @@ exports.KNOWN = {
     'mcp install': ['show-token'],
     functions: ['project'],
     'functions list': ['project'],
-    'functions invoke': ['data', 'data-file', 'method', 'project'],
+    'functions invoke': ['data', 'data-file', 'json', 'method', 'project'],
     'functions logs': ['limit', 'project'],
     logs: ['limit', 'project'],
     env: ['project'],

package/dist/help.js

@@ -472,14 +472,15 @@ Both are taken from the platform, no local .env is needed.
   --data '{"a":1}'        request body (the method becomes POST by default)
   --data-file body.json   the same body from a file
   --method GET            a different method
+  --json                  the answer of the function alone, exactly as it came
 
 The body has to be JSON, and it is checked before the call goes out: PowerShell
 strips double quotes from a native call, so ${(0, ui_1.bold)('--data')} needs them escaped there
 (${(0, ui_1.bold)('--data \'{\\"a\\":1}\'')}) and a file needs nothing.
 
-Prints the status, the response time and the body. A non-zero exit code on 4xx and
-5xx: in CI such a call has to fail the step. The cause of a crash is shown by
-${(0, ui_1.bold)('xflow functions logs <name>')}.`,
+Prints the status, the response time and the body; under ${(0, ui_1.bold)('--json')} the body
+alone. A non-zero exit code on 4xx and 5xx: in CI such a call has to fail the step.
+The cause of a crash is shown by ${(0, ui_1.bold)('xflow functions logs <name>')}.`,
     mcp: `${(0, ui_1.bold)('xflow mcp install')}: connect the agent to the platform directly
 
 Writes the MCP server into the configuration of a client that has its own connect

package/dist/template.js

@@ -1,9 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.FUNCTIONS_ENV_KEY = void 0;
-exports.functionsEnvValue = functionsEnvValue;
-exports.envFile = envFile;
-exports.writeEnvValue = writeEnvValue;
+exports.writePlatformEnv = writePlatformEnv;
 exports.scaffoldFiles = scaffoldFiles;
 const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
@@ -32,7 +29,7 @@ tokens from \`src/index.css\` break that consistency.
 Useful: \`xflow status\` for what is on the server, \`xflow deployments\` for version history.
 `;
 /** Function name → URL map, one JSON line. */
-exports.FUNCTIONS_ENV_KEY = 'VITE_XFLOW_FUNCTIONS';
+const FUNCTIONS_ENV_KEY = 'VITE_XFLOW_FUNCTIONS';
 function functionsEnvValue(functions) {
     const map = {};
     for (const fn of functions) {
@@ -41,14 +38,14 @@ function functionsEnvValue(functions) {
     }
     return JSON.stringify(map);
 }
-/** .env is never pushed; xflow link recreates it in a fresh clone. */
-function envFile(projectToken, apiUrl, functions = []) {
-    return [
-        `VITE_XFLOW_PROJECT_TOKEN=${projectToken}`,
-        `VITE_XFLOW_API_URL=${apiUrl.replace(/^https?:\/\//, '')}`,
-        `${exports.FUNCTIONS_ENV_KEY}=${functionsEnvValue(functions)}`,
-        '',
-    ].join('\n');
+/**
+ * Point .env at the current project: written on every link and deploy, so that `npm run dev`
+ * never keeps talking to the previous one. Variables of your own are left alone.
+ */
+function writePlatformEnv(root, projectToken, apiUrl, functions = []) {
+    writeEnvValue(root, 'VITE_XFLOW_PROJECT_TOKEN', projectToken ?? '');
+    writeEnvValue(root, 'VITE_XFLOW_API_URL', apiUrl.replace(/^https?:\/\//, ''));
+    writeEnvValue(root, FUNCTIONS_ENV_KEY, functionsEnvValue(functions));
 }
 /** Update one variable in .env without touching the rest of the file. */
 function writeEnvValue(root, key, value) {

package/dist/version.js

@@ -2,6 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULT_API_URL = exports.CLI_VERSION = void 0;
 /** Keep in sync with cli/package.json. */
-exports.CLI_VERSION = '0.15.0';
+exports.CLI_VERSION = '0.17.0';
 /** Overridden by XFLOW_API_URL or the `api` field in xflow.json. */
 exports.DEFAULT_API_URL = 'https://app.getxflow.com';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getxflow/cli",
-  "version": "0.15.0",
+  "version": "0.17.0",
   "description": "CLI for the XFlow platform: source sync, deployment and publishing of applications",
   "license": "UNLICENSED",
   "engines": {

package/skills/xflow/SKILL.md

@@ -24,7 +24,7 @@ contains the fix.
 
 ## Keeping these instructions current
 
-These instructions ship with xflow CLI 0.15.0. They travel inside the package, so the copy
+These instructions ship with xflow CLI 0.17.0. They travel inside the package, so the copy
 you are reading can be older than the CLI answering your commands, and nothing about that
 is visible in the text itself.
 
@@ -122,9 +122,10 @@ the very first version of a project: it publishes automatically, since there is
 live version to protect yet.
 
 `xflow status` says how the local copy differs from the server revision. When a deploy is
-rejected before the build starts, the server revision is newer: somebody deployed first.
-Fetch their work next to yours (`xflow pull --into ./server-copy`), merge it in git, deploy
-again. `--force` destroys their work, a last resort rather than a way around the error.
+rejected before the build starts, the server holds a version this folder has never seen:
+somebody deployed first, or the folder was linked to a different project along the way.
+Fetch the server work next to yours (`xflow pull --into ./server-copy`), merge it in git,
+deploy again. `--force` destroys that work, a last resort rather than a way around the error.
 
 **Only pages are versioned.** Cloud functions and the database are one per project: they
 are not versioned, and dev and live share them. So `xflow deploy` changes the running
@@ -256,8 +257,9 @@ which functions are about to go and let the user answer.
 
 Debugging a deployed function is two commands: `xflow functions invoke <name>` calls it
 the way the app does and prints status, timing and body (`--data '{"a":1}'` sends a body,
-`--data-file body.json` sends the same from a file), and `xflow functions logs <name>` shows
-the failures, each with its stack and the console output of that call. Only failed calls are
+`--data-file body.json` sends the same from a file, `--json` prints the body alone), and
+`xflow functions logs <name>` shows the failures, each with its stack and the console
+output of that call. Only failed calls are
 logged, so an empty output means the function never crashed, not that logging is broken.
 
 The body has to be JSON and the CLI checks it before calling. In PowerShell the double