@getxflow/cli 0.34.2 → 1.0.0

package/dist/limits.js

@@ -4,8 +4,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.limitLine = limitLine;
 exports.quotaRows = quotaRows;
 const DENIAL_LABELS = {
-    limit_projects: 'projects',
-    limit_databases: 'databases',
+    limit_projects: 'projects, the platform cap',
+    limit_apps: 'apps',
+    plan_app_access: 'access levels of apps',
+    functions_stopped: 'function minutes, the functions of the organization are stopped',
     limit_connections: 'active connector connections',
     limit_pages: 'public pages',
     limit_functions: 'cloud functions',
@@ -32,8 +34,7 @@ function limitLine(detail) {
     return `Plan limit: ${label}${numbers}. Repeating the same command will not help.`;
 }
 const QUOTA_ORDER = [
-    'projects',
-    'databases',
+    'apps',
     'connections',
     'pages',
     'functions',
@@ -45,8 +46,7 @@ const QUOTA_ORDER = [
     'builds',
 ];
 const QUOTA_LABELS = {
-    projects: 'Projects',
-    databases: 'Databases',
+    apps: 'Apps',
     connections: 'Active connections',
     pages: 'Public pages',
     functions: 'Cloud functions',

package/dist/session.js

@@ -6,6 +6,13 @@ exports.findProjectOrg = findProjectOrg;
 exports.connectProject = connectProject;
 exports.isProjectId = isProjectId;
 exports.projectTarget = projectTarget;
+exports.parseTargetWord = parseTargetWord;
+exports.onlyApp = onlyApp;
+exports.folderTarget = folderTarget;
+exports.appTarget = appTarget;
+exports.streamTarget = streamTarget;
+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");
@@ -15,9 +22,8 @@ const ui_1 = require("./ui");
 /**
  * Platform connection: address plus key.
  *
- * `ignoreFolder` is what --project needs: the folder around it belongs to another
- * project, so its organization must not decide the key. Taking it would hand the
- * flag the key of the wrong organization, and the answer would be a bare 404.
+ * `ignoreFolder` is what --project and --app need: the folder around it belongs to
+ * another project, so its organization must not decide the key.
  */
 function connect(config, options) {
     const apiUrl = (0, config_1.apiUrlFor)(config);
@@ -31,11 +37,7 @@ function connect(config, options) {
         ...(0, credentials_1.storedKeyInputs)(apiUrl),
     });
     if (!picked) {
-        throw new errors_1.CliError(`No access key for ${apiUrl}`, 
-        // Who does it, not where the key comes from: the key is issued by the sign-in
-        // itself and by nothing else, so an agent reading this has to hand the step over
-        // instead of hunting for a value to paste.
-        'Sign in: xflow login (needs a person with a browser). In CI pass the key in XFLOW_TOKEN');
+        throw new errors_1.CliError(`No access key for ${apiUrl}`, 'Sign in: xflow login (needs a person with a browser). In CI pass the key in XFLOW_TOKEN');
     }
     if ('missing' in picked) {
         throw new errors_1.CliError(`This folder is bound to the organization ${picked.organizationId}, and there is no stored key for it`, 'Sign in to that organization: xflow login. The stored ones: xflow org');
@@ -47,16 +49,15 @@ function anonymous(config) {
     return { apiUrl: (0, config_1.apiUrlFor)(config), token: '' };
 }
 /**
- * Which signed-in organization serves the project. Project ids are unique
- * across the platform, so a 404 means "not this one" and exactly one
- * organization can answer. A dead key must not end the search: the answer may
- * sit behind the next one.
+ * Which signed-in organization answers this path. Ids are unique across the
+ * platform, so a 404 means "not this one" and exactly one organization can answer.
+ * A dead key must not end the search: the answer may sit behind the next one.
  */
-async function findProjectOrg(apiUrl, projectId) {
+async function findOrgFor(apiUrl, path) {
     const dead = [];
     for (const candidate of (0, credentials_1.listOrgs)(apiUrl)) {
         try {
-            await (0, api_1.apiJson)({ apiUrl, token: candidate.token }, `/api/v1/projects/${projectId}`);
+            await (0, api_1.apiJson)({ apiUrl, token: candidate.token }, path);
             return { hit: candidate, dead };
         }
         catch (e) {
@@ -71,28 +72,26 @@ async function findProjectOrg(apiUrl, projectId) {
     }
     return { hit: null, dead };
 }
+function findProjectOrg(apiUrl, projectId) {
+    return findOrgFor(apiUrl, `/api/v1/projects/${projectId}`);
+}
 /**
- * Connection for project commands. A folder not yet bound to an organization
- * gets probed once: the organization that serves the project is found and
- * written into .xflow/state.json, so every later command resolves the key
- * synchronously. With one stored key there is nothing to probe.
- *
- * Without a folder (--project) there is nowhere to write the answer, so the
- * probe repeats on every command. Kept that way on purpose: a second store of
- * "which organization holds what" would be a second truth to keep in step, and
- * the price is paid only by whoever did not switch the active organization.
+ * Connection for a project or an app. A folder not yet bound to an organization
+ * gets probed once and the answer written into .xflow/state.json of the project
+ * root. Named by id there is nowhere to write it, so the probe repeats: a second
+ * store of "which organization holds what" would be a second truth to keep true.
  */
-async function connectProject(projectId, root, config) {
+async function connectFor(path, what, root, config) {
     const session = connect(config, { ignoreFolder: root === null });
     if (session.source !== 'active')
         return session;
     const orgs = (0, credentials_1.listOrgs)(session.apiUrl);
     if (orgs.length <= 1)
         return session;
-    const { hit, dead } = await findProjectOrg(session.apiUrl, projectId);
+    const { hit, dead } = await findOrgFor(session.apiUrl, path);
     if (!hit) {
-        throw new errors_1.CliError(`No signed-in organization holds the project ${projectId}`, dead.length > 0
-            ? `The key of ${dead.map((d) => d.name ?? d.organizationId).join(', ')} is not working (sign in again: xflow login); the project may live there`
+        throw new errors_1.CliError(`No signed-in organization holds the ${what}`, dead.length > 0
+            ? `The key of ${dead.map((d) => d.name ?? d.organizationId).join(', ')} is not working (sign in again: xflow login); it may live there`
             : root === null
                 ? 'Check the id, or sign in to the organization that owns it: xflow login'
                 : 'Check projectId in xflow.json, or sign in to the organization that owns it: xflow login');
@@ -103,35 +102,31 @@ async function connectProject(projectId, root, config) {
             (0, ui_1.note)((0, ui_1.dim)(`  The project belongs to "${hit.name ?? hit.organizationId}", not to the active organization: the folder is bound to it`));
         }
     }
-    return {
-        apiUrl: session.apiUrl,
-        token: hit.token,
-        source: root === null ? 'probe' : 'folder',
-        organizationId: hit.organizationId,
-    };
+    return { apiUrl: session.apiUrl, token: hit.token, source: root === null ? 'probe' : 'folder', organizationId: hit.organizationId };
+}
+function connectProject(projectId, root, config) {
+    return connectFor(`/api/v1/projects/${projectId}`, `project ${projectId}`, root, config);
 }
 /**
- * A project id, and nothing that could be mistaken for one. A name passed where
- * the id belongs would answer a bare 404, and that reads as "no such project"
+ * A project or app id, and nothing that could be mistaken for one. A name passed
+ * where the id belongs would answer a bare 404, which reads as "no such project"
  * rather than "wrong argument".
  */
 function isProjectId(value) {
     return /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(value);
 }
+/** Echoed on every human run: an id typed by hand answers 404 on a read and works on a write. */
+function echoNamed(client, line) {
+    const org = (0, credentials_1.listOrgs)(client.apiUrl).find((entry) => entry.organizationId === client.organizationId);
+    (0, ui_1.note)((0, ui_1.dim)(`  ${line}${org ? ` of "${org.name ?? org.organizationId}"` : ''}`));
+}
 /**
- * The project a command works on: the --project flag, or the folder it runs in.
+ * The project a command works on: the --project flag, or the project root of the
+ * folder it runs in (any folder of the project, apps included).
  *
  * The flag ignores the folder whole, its xflow.json included, so the address is
- * the default one or XFLOW_API_URL and nothing else: a config lying around must
- * not be able to redirect a call made by id.
- *
- * Either way the key comes from connectProject: an unbound folder gets the
- * organization of its project looked up once and written down, an id gets it
- * looked up on every call.
- *
- * `root` is that folder, and null when the id was named: a command that reads the
- * sources for a check of its own then knows the check is not available rather than
- * running it against whatever folder the caller happened to stand in.
+ * the default one or XFLOW_API_URL: a config lying around must not redirect a call
+ * made by id. `root` is null then.
  */
 async function projectTarget(args) {
     const named = (0, args_1.flagString)(args, 'project');
@@ -140,15 +135,135 @@ async function projectTarget(args) {
             throw new errors_1.CliError(`--project takes a project id, got "${named}"`, 'The ids: xflow projects list');
         }
         const client = await connectProject(named, null);
-        // Echoed back on every human run: the flag is the only place the id is typed by
-        // hand, and a wrong one answers 404 on a read and works on a write. The
-        // organization is named too, since it may not be the active one. Under --json
-        // the line is silenced with the rest, where the payload is the whole answer.
-        const org = (0, credentials_1.listOrgs)(client.apiUrl).find((entry) => entry.organizationId === client.organizationId);
-        (0, ui_1.note)((0, ui_1.dim)(`  Project ${named}${org ? ` of "${org.name ?? org.organizationId}"` : ''} (--project)`));
+        echoNamed(client, `Project ${named} (--project)`);
         return { projectId: named, client, root: null };
     }
     const { root, config } = (0, config_1.requireProject)();
     const client = await connectProject(config.projectId, root, config);
     return { projectId: config.projectId, client, root };
 }
+/** The word after a command: `functions` is the project stream, anything else a path to an app folder. */
+function parseTargetWord(word) {
+    if (word === undefined)
+        return null;
+    if (word === 'functions')
+        return { kind: 'functions' };
+    return { kind: 'path', path: word.replace(/\\/g, '/').replace(/\/+$/, '') || '.' };
+}
+/** The app of a project that names none: the only one, or a refusal listing them. */
+function onlyApp(apps, local) {
+    if (apps.length === 1)
+        return apps[0];
+    if (apps.length === 0)
+        throw new errors_1.CliError('The project has no apps', 'Create one: xflow apps add <folder>');
+    const names = apps.map((app) => {
+        const folder = local.find((item) => item.appId === app.id)?.folder;
+        return folder ? `apps/${folder}` : `--app ${app.id} (${app.name})`;
+    });
+    throw new errors_1.CliError('The project has several apps: name the one', `Stand in its folder or name it: ${names.join(', ')}`);
+}
+function appsHint(projectRoot) {
+    const apps = projectRoot ? (0, config_1.localApps)(projectRoot) : [];
+    return apps.length > 0
+        ? `The app folders here: ${apps.map((app) => `apps/${app.folder}`).join(', ')}`
+        : 'Apps are created with xflow apps add <folder>';
+}
+/** The app folder a typed path names: relative to where you stand, then to the project root. */
+function appFolderFor(path, projectRoot) {
+    for (const base of [process.cwd(), projectRoot]) {
+        if (!base)
+            continue;
+        const dir = (0, node_path_1.resolve)(base, path);
+        const file = (0, node_path_1.join)(dir, config_1.CONFIG_FILE);
+        if ((0, node_fs_1.existsSync)(file) && (0, config_1.configKind)(safeRead(file)) === 'app')
+            return dir;
+    }
+    return null;
+}
+function safeRead(file) {
+    try {
+        return JSON.parse((0, node_fs_1.readFileSync)(file, 'utf-8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+async function appInFolder(folder) {
+    const roots = (0, config_1.findRoots)(folder);
+    if (!roots)
+        throw new errors_1.CliError(`${folder} is not inside a project`);
+    const config = (0, config_1.readConfig)(roots.projectRoot);
+    const { appId } = (0, config_1.readAppConfig)(folder);
+    const client = await connectProject(config.projectId, roots.projectRoot, config);
+    return { kind: 'app', appId, projectId: config.projectId, client, root: folder, projectRoot: roots.projectRoot };
+}
+/** An app named by id: its project comes from the platform. */
+async function appById(appId) {
+    if (!isProjectId(appId)) {
+        throw new errors_1.CliError(`--app takes an app id, got "${appId}"`, 'The apps of a project: xflow apps --project <id>');
+    }
+    const client = await connectFor(`/api/v1/apps/${appId}`, `app ${appId}`, null);
+    const card = await (0, api_1.apiJson)(client, `/api/v1/apps/${appId}`);
+    echoNamed(client, `App ${card.name} ${appId} (--app)`);
+    return { kind: 'app', appId, projectId: card.project_id, client, root: null, projectRoot: null };
+}
+/**
+ * The target of a command that stands in the folder: the word first, then the folder.
+ * `appCommand` commands (publish, deployments of an app, logs) have no project stream
+ * of their own, so in the project root they take the only app or refuse.
+ */
+async function folderTarget(word, appCommand) {
+    const parsed = parseTargetWord(word);
+    if (parsed?.kind === 'path') {
+        const projectRoot = (0, config_1.findProjectRoot)();
+        const folder = appFolderFor(parsed.path, projectRoot);
+        if (!folder) {
+            throw new errors_1.CliError(`${word} is not an app folder: there is no ${config_1.CONFIG_FILE} with appId in it`, appsHint(projectRoot));
+        }
+        return appInFolder(folder);
+    }
+    const { root, config, appRoot } = (0, config_1.requireProject)();
+    if (appRoot && parsed === null)
+        return appInFolder(appRoot);
+    const client = await connectProject(config.projectId, root, config);
+    if (!appCommand || parsed?.kind === 'functions')
+        return { kind: 'project', projectId: config.projectId, client, root };
+    const card = await (0, api_1.apiJson)(client, `/api/v1/projects/${config.projectId}`);
+    const local = (0, config_1.localApps)(root);
+    const app = onlyApp(card.apps, local);
+    return {
+        kind: 'app',
+        appId: app.id,
+        projectId: config.projectId,
+        client,
+        root: local.find((item) => item.appId === app.id)?.root ?? null,
+        projectRoot: root,
+    };
+}
+/** An app by --app, or by the folder (in the project root: the only app). */
+async function appTarget(args) {
+    const byApp = (0, args_1.flagString)(args, 'app');
+    const target = byApp !== undefined ? await appById(byApp) : await folderTarget(undefined, true);
+    if (target.kind !== 'app')
+        throw new errors_1.CliError('Only an app has versions to publish', 'Functions go live with xflow deploy functions');
+    return target;
+}
+/** The same, with --project (the project stream) and --app (an app) naming the target without a folder. */
+async function streamTarget(args, word, appCommand) {
+    const byApp = (0, args_1.flagString)(args, 'app');
+    const byProject = (0, args_1.flagString)(args, 'project');
+    if (byApp !== undefined) {
+        if (byProject !== undefined)
+            throw new errors_1.CliError('--app names the app and its project at once', 'Keep --app alone');
+        if (word !== undefined)
+            throw new errors_1.CliError(`--app and "${word}" both name a target`, 'Keep one of them');
+        return appById(byApp);
+    }
+    if (byProject !== undefined) {
+        if (parseTargetWord(word)?.kind === 'path') {
+            throw new errors_1.CliError(`--project and "${word}" both name a target`, 'An app without its folder: --app <id>');
+        }
+        return { kind: 'project', ...(await projectTarget(args)) };
+    }
+    return folderTarget(word, appCommand);
+}

package/dist/template.js

@@ -1,141 +1,45 @@
 "use strict";
+/** Files the CLI lays into a new project root: the app itself comes from the platform template. */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.envApiUrl = envApiUrl;
-exports.platformEnv = platformEnv;
-exports.writePlatformEnv = writePlatformEnv;
-exports.scaffoldFiles = scaffoldFiles;
-exports.functionScaffoldFiles = functionScaffoldFiles;
-const node_fs_1 = require("node:fs");
-const node_path_1 = require("node:path");
-const GITIGNORE = `node_modules/
-dist/
-.xflow/
-.env
-.env.*
+exports.projectScaffold = projectScaffold;
+const GITIGNORE = `node_modules/
+dist/
+.xflow/
+.env
+.env.*
 `;
-const README = `# %NAME%
-
-An application on XFlow.
-
-\`\`\`bash
-npm install       # dependencies
-xflow dev         # develop on 127.0.0.1:3000
-xflow deploy      # send the code and build it on the platform
-xflow publish     # show the dev version to visitors
-\`\`\`
-
-The interface is built on the template components: \`src/components/ui\` (buttons, fields,
-dialogs) and \`src/components/blocks\` (a data table and charts). Layout built
-on top of them looks like the rest of the platform, while custom colors in place of the
-tokens from \`src/index.css\` break that consistency.
-
-Useful: \`xflow status\` for what is on the server, \`xflow deployments\` for version history.
+const README = `# %NAME%
+
+A project on XFlow: one database, cloud functions and the apps that use them.
+
+\`\`\`
+xflow.json          projectId, and which apps and pages may call each function
+package.json        dependencies of the functions
+functions/<name>/   cloud functions, shared by every app
+migrations/         the database of the project
+apps/<folder>/      an app: its own code, versions and address
+\`\`\`
+
+\`\`\`bash
+xflow deploy functions -m "..."      # ship the functions and their callers
+xflow deploy apps/<folder> -m "..."  # build one app
+xflow publish                        # inside an app folder: show the newest build
+xflow status                         # what is on the server
+\`\`\`
 `;
-/** Function name → URL map, one JSON line. */
-const FUNCTIONS_ENV_KEY = 'VITE_XFLOW_FUNCTIONS';
-function functionsEnvValue(functions) {
-    const map = {};
-    for (const fn of functions) {
-        if (fn.invoke_url)
-            map[fn.name] = fn.invoke_url;
-    }
-    return JSON.stringify(map);
-}
-/** The platform address the way .env holds it, and the way every template reads it. */
-function envApiUrl(apiUrl) {
-    return apiUrl.replace(/^https?:\/\//, '');
-}
-/** The variables that point a local run at the project: written to .env, handed to xflow dev. */
-function platformEnv(projectToken, apiUrl, functions = [], 
-// The map the platform assembled: it also holds the standalone functions of the
-// organization. Own functions alone are the fallback for a platform without it.
-map) {
-    return {
-        VITE_XFLOW_PROJECT_TOKEN: projectToken ?? '',
-        VITE_XFLOW_API_URL: envApiUrl(apiUrl),
-        [FUNCTIONS_ENV_KEY]: map ? JSON.stringify(map) : functionsEnvValue(functions),
-    };
-}
-/**
- * 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 = [], map) {
-    for (const [key, value] of Object.entries(platformEnv(projectToken, apiUrl, functions, map))) {
-        writeEnvValue(root, key, value);
-    }
-}
-/** Update one variable in .env without touching the rest of the file. */
-function writeEnvValue(root, key, value) {
-    const path = (0, node_path_1.join)(root, '.env');
-    const line = `${key}=${value}`;
-    if (!(0, node_fs_1.existsSync)(path)) {
-        (0, node_fs_1.writeFileSync)(path, `${line}\n`, 'utf-8');
-        return;
-    }
-    const text = (0, node_fs_1.readFileSync)(path, 'utf-8');
-    const existing = new RegExp(`^${key}=.*$`, 'm');
-    const next = existing.test(text) ? text.replace(existing, line) : `${text.replace(/\n*$/, '\n')}${line}\n`;
-    if (next !== text)
-        (0, node_fs_1.writeFileSync)(path, next, 'utf-8');
-}
-function scaffoldFiles(projectName) {
-    return [
-        { path: '.gitignore', content: GITIGNORE },
-        { path: 'README.md', content: README.replace('%NAME%', projectName.replace(/"/g, '\\"')) },
-    ];
-}
-/**
- * A standalone function has no site, so it gets no Vite tree: one handler, and
- * esbuild, which the sandbox takes from the project to bundle the function.
- */
-const FUNCTION_HANDLER = `/**
- * Cloud function of the %NAME% project.
- *
- * XFlow calls it over HTTP and, if a schedule is set, on a timer. The answer is
- * { statusCode, body }, where body is a string.
- */
-export async function handler(event: {
-  httpMethod: string;
-  body: string | null;
-  queryStringParameters: Record<string, string> | null;
-}) {
-  const input = event.body ? JSON.parse(event.body) : {};
-
-  return {
-    statusCode: 200,
-    body: JSON.stringify({ ok: true, method: event.httpMethod, input }),
-  };
-}
-`;
-const FUNCTION_README = `# %NAME%
-
-A standalone function on XFlow: a shared backend for the applications of the
-organization, without a site of its own.
-
-\`\`\`bash
-npm install       # dependencies
-xflow deploy      # send the code, build and release the function
-xflow functions   # its address and status
-\`\`\`
-
-The code lives in \`functions/%FUNCTION%/index.ts\`. A schedule, keys and secrets
-are set in the platform, in the "Functions" section.
-`;
-function functionScaffoldFiles(projectName, functionName) {
-    const fill = (text) => text.replace(/%NAME%/g, projectName.replace(/"/g, '\\"')).replace(/%FUNCTION%/g, functionName);
+function projectScaffold(projectName) {
     return [
         { path: '.gitignore', content: GITIGNORE },
-        { path: 'README.md', content: fill(FUNCTION_README) },
+        { path: 'README.md', content: README.replace('%NAME%', projectName) },
         {
             path: 'package.json',
             content: `${JSON.stringify({
-                name: functionName,
+                name: 'functions',
                 private: true,
                 type: 'module',
+                // The sandbox bundles every function with the esbuild of the project.
                 devDependencies: { esbuild: '0.28.2' },
             }, null, 2)}\n`,
         },
-        { path: `functions/${functionName}/index.ts`, content: fill(FUNCTION_HANDLER) },
     ];
 }

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.34.2';
+exports.CLI_VERSION = '1.0.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,7 +1,7 @@
 {
   "name": "@getxflow/cli",
-  "version": "0.34.2",
-  "description": "CLI for the XFlow platform: source sync, deployment and publishing of applications",
+  "version": "1.0.0",
+  "description": "CLI for the XFlow platform: projects with apps, functions and a database; source sync, deployment and publishing",
   "license": "UNLICENSED",
   "engines": {
     "node": ">=20"