@faable/faable 3.4.2 → 4.0.0

package/dist/commands/whoami/index.js

@@ -1,12 +1,41 @@
 import { log } from '../../log.js';
 import { getMe } from '../../api/auth.js';
+import { resolveTenant } from '../../api/auth_admin.js';
+import { FaableApi } from '../../api/FaableApi.js';
+import { SOURCE_LABEL, requireProject } from '../../api/project.js';
 import { loadLiveCredentials } from '../../api/session.js';
+import { bearer_strategy } from '../../api/strategies/bearer.strategy.js';
 import { CredentialsStore } from '../../lib/CredentialsStore.js';
+import { print_json, print, json_option } from '../../lib/listing.js';
 
+// Who you are, and what the CLI acts on: the active project and the Auth
+// tenant `faable auth` would manage. The context is best-effort — a missing
+// project is something to show, not a reason to fail `whoami`.
+const describeContext = async (token) => {
+    const api = FaableApi.create({ authStrategy: bearer_strategy, auth: { token } });
+    let project;
+    let tenant;
+    try {
+        const { id, source } = await requireProject(api);
+        const p = await api.getProject(id).catch(() => undefined);
+        project = { id, name: p?.name, source };
+    }
+    catch (e) {
+        project = { error: e.message };
+    }
+    try {
+        tenant = await resolveTenant({}, api);
+    }
+    catch (e) {
+        tenant = { error: e.message };
+    }
+    return { project, tenant };
+};
 const whoami = {
     command: "whoami",
-    describe: "Display the current logged in user",
-    handler: async () => {
+    describe: "Show the logged in user, the active project and its Auth tenant",
+    builder: (yargs) => json_option(yargs),
+    handler: async (args) => {
         const store = new CredentialsStore();
         // Auto-refreshes an expired token via the stored refresh_token.
         const config = await loadLiveCredentials(store);
@@ -16,22 +45,43 @@ const whoami = {
             // API-key sessions can't be introspected at the auth server's /me; fall
             // back to the email captured at login time.
             if (config?.apikey && config.email) {
-                log.info(`Logged in as: ${config.email} (API key)`);
+                if (args.json)
+                    return print_json({ email: config.email, credential: "apikey" });
+                print(`Logged in as: ${config.email} (API key)`);
                 return;
             }
             log.error("❌ Not logged in. Run 'faable login' first.");
             process.exit(1);
         }
+        let me;
         try {
             // Validate against the Auth server (it issued the token); the deploy API
             // has no /me route.
-            const me = await getMe(token);
-            log.info(`Logged in as: ${me.email}`);
+            me = await getMe(token);
         }
         catch {
             log.error("❌ Not logged in or session expired");
             process.exit(1);
         }
+        const { project, tenant } = await describeContext(token);
+        if (args.json) {
+            return print_json({ email: me.email, credential: "token", project, auth_tenant: tenant });
+        }
+        print(`Logged in as: ${me.email}`);
+        if ("error" in project) {
+            print(`Project:      none — faable project use <id|name>`);
+        }
+        else {
+            const name = project.name ? `${project.name} (${project.id})` : project.id;
+            print(`Project:      ${name}  [${SOURCE_LABEL[project.source]}]`);
+        }
+        if ("error" in tenant) {
+            print(`Auth tenant:  none — ${tenant.error}`);
+        }
+        else {
+            const parts = [tenant.name, tenant.account && `(${tenant.account})`, tenant.domain];
+            print(`Auth tenant:  ${parts.filter(Boolean).join(" ")}`);
+        }
     },
 };
 

package/dist/index.js

@@ -5,13 +5,16 @@ import { deploy } from './commands/deploy/index.js';
 import { link_deprecated } from './commands/link/index.js';
 import { login } from './commands/login/index.js';
 import { logout } from './commands/logout/index.js';
+import { project } from './commands/project/index.js';
 import { upgrade } from './commands/upgrade/index.js';
 import { whoami } from './commands/whoami/index.js';
 import { version } from './config.js';
 import { Configuration } from './lib/Configuration.js';
+import { setProjectFlag } from './api/project.js';
 import { notifyIfUpdateAvailable } from './lib/UpdateChecker.js';
 import { log } from './log.js';
 
+const wants_json = () => process.argv.includes('--json');
 // yargs re-runs before-validation middlewares once per nested command level
 // (`deploy secrets` = 2 runs), so keep the banner and update check to one.
 let banner_shown = false;
@@ -27,7 +30,8 @@ yg.scriptName('faable')
     // update-check notice). Same for `auth users export` without a file,
     // whose stdout IS the export.
     const exports_to_stdout = argv._.slice(0, 3).join(' ') === 'auth users export' && !argv.file;
-    if (argv.json || exports_to_stdout)
+    // Nor when nobody is watching stderr (a script, the MCP server).
+    if (argv.json || exports_to_stdout || !process.stderr.isTTY)
         return;
     log.info(`Faable CLI ${version}`);
     // `upgrade` does its own (forced) check
@@ -39,8 +43,15 @@ yg.scriptName('faable')
     alias: 'config',
     description: 'Path to the local `faable.json` file',
     string: true
+})
+    .option('p', {
+    alias: 'project',
+    description: 'Project to act on, id or name (env FAABLE_PROJECT; default: `faable project use`)',
+    string: true,
+    global: true
 })
     .middleware(function (argv) {
+    setProjectFlag(argv.project);
     if (argv.config) {
         Configuration.instance().setConfigFile(argv.config, {
             ignoreWarnings: false
@@ -52,6 +63,7 @@ yg.scriptName('faable')
 }, true)
     .command(deploy)
     .command(auth)
+    .command(project)
     .command(login)
     .command(logout)
     .command(whoami)
@@ -65,7 +77,21 @@ yg.scriptName('faable')
     .help()
     .fail(function (msg, err) {
     if (err) {
-        log.error(`❌ ${err.message}`);
+        // With --json the caller is a program: the error as JSON too, on
+        // stderr, so it can tell a 404 from a 403 without parsing prose.
+        if (wants_json()) {
+            const e = err;
+            process.stderr.write(JSON.stringify({
+                error: {
+                    message: e.message,
+                    ...(e.code ? { code: e.code } : {}),
+                    ...(e.status ? { status: e.status } : {})
+                }
+            }) + '\n');
+        }
+        else {
+            log.error(`❌ ${err.message}`);
+        }
         process.exit(1);
         return;
     }

package/dist/lib/ContextStore.js

@@ -0,0 +1,30 @@
+import fs from 'fs-extra';
+import os from 'os';
+import path__default from 'path';
+
+class ContextStore {
+    faable_home;
+    constructor(faable_home = path__default.join(os.homedir(), '.faable')) {
+        this.faable_home = faable_home;
+    }
+    get path() {
+        return path__default.join(this.faable_home, 'config.json');
+    }
+    async load() {
+        try {
+            return (await fs.readJSON(this.path)) || {};
+        }
+        catch {
+            return {};
+        }
+    }
+    async update(patch) {
+        const next = patch(await this.load());
+        await fs.ensureDir(this.faable_home);
+        await fs.writeJSON(this.path, next, { spaces: 2 });
+        await fs.chmod(this.path, 0o600);
+        return next;
+    }
+}
+
+export { ContextStore };

package/dist/lib/listing.js

@@ -0,0 +1,91 @@
+// One listing contract for every `faable … list`, modelled on Stripe's CLI so
+// a script — or the MCP server that will drive this CLI — learns it once:
+//
+//   --limit N              one page of up to N items (default 100, max 200)
+//   --starting-after CUR   the page after CUR (the previous page's next_cursor)
+//   --all                  walk every page
+//   --json                 {"object":"list","data":[…],"has_more",…,"next_cursor"}
+//
+// The servers page by cursor (`pageSize` + `next`, arch/api/pagination.md);
+// this is the translation. There is no --ending-before: the cursor only runs
+// forward.
+const MAX_PAGE_SIZE = 200;
+const DEFAULT_PAGE_SIZE = 100;
+const json_option = (yargs) => yargs.option('json', {
+    type: 'boolean',
+    default: false,
+    description: 'Output JSON on stdout (for scripting)'
+});
+const list_options = (yargs, { default_limit = DEFAULT_PAGE_SIZE } = {}) => json_option(yargs)
+    .option('limit', {
+    alias: 'n',
+    type: 'number',
+    default: default_limit,
+    description: `Items per page (1-${MAX_PAGE_SIZE})`
+})
+    .option('starting-after', {
+    alias: 'cursor',
+    type: 'string',
+    description: 'Cursor to continue from (the next_cursor of the previous page)'
+})
+    .option('all', {
+    type: 'boolean',
+    default: false,
+    description: 'Fetch every page'
+})
+    .check(argv => {
+    const limit = argv.limit;
+    if (limit !== undefined &&
+        (!Number.isInteger(limit) || limit < 1 || limit > MAX_PAGE_SIZE)) {
+        throw new Error(`--limit must be an integer between 1 and ${MAX_PAGE_SIZE}`);
+    }
+    return true;
+});
+// A page of the server's `{ results, next }` from the listing flags. With
+// --all the cursor is walked here rather than by the SDK paginator's `.all()`,
+// which gives up at 100 pages.
+const fetch_page = async (fetch, args) => {
+    const pageSize = args.all ? MAX_PAGE_SIZE : args.limit;
+    let next = args.startingAfter || undefined;
+    const data = [];
+    do {
+        const page = await fetch({ pageSize, ...(next ? { next } : {}) });
+        data.push(...page.results);
+        const following = page.next || undefined;
+        if (following && following === next)
+            throw new Error('Bad next cursor');
+        next = following;
+    } while (args.all && next);
+    return as_list(data, next ?? null);
+};
+const from_paginator = (listing) => ({ pageSize, next }) => listing.pass({ pageSize: String(pageSize), ...(next ? { cursor: next } : {}) });
+const as_list = (data, next_cursor = null) => ({
+    object: 'list',
+    data,
+    has_more: !!next_cursor,
+    next_cursor
+});
+// Data goes to stdout, untouched by the logger (which writes to stderr).
+const print = (line = '') => {
+    process.stdout.write(line + '\n');
+};
+const print_json = (data) => {
+    print(JSON.stringify(data, null, 2));
+};
+// The rerun hint for the next page, on stderr (the logger's): shown to a
+// person, invisible to a pipe.
+const more_hint = (page) => page.has_more
+    ? `… more results: rerun with --starting-after ${page.next_cursor} (or --all)`
+    : undefined;
+// Left-padded fixed-width table lines. Cells are stringified as-is; column
+// width = max(header, cells).
+const table_lines = (headers, rows) => {
+    const widths = headers.map((h, i) => Math.max(h.length, ...rows.map(r => (r[i] ?? '').length)));
+    const render = (cells) => cells
+        .map((c, i) => (i === cells.length - 1 ? c : (c ?? '').padEnd(widths[i])))
+        .join('  ')
+        .trimEnd();
+    return [render(headers), ...rows.map(render)];
+};
+
+export { DEFAULT_PAGE_SIZE, MAX_PAGE_SIZE, as_list, fetch_page, from_paginator, json_option, list_options, more_hint, print, print_json, table_lines };

package/dist/log.js

@@ -6,6 +6,10 @@ import { buildLog } from './lib/log_buffer.js';
 // transport: the worker's MessagePort can stay referenced after the last log
 // (thread-stream race) and intermittently keep the CLI from exiting.
 //
+// Messages go to STDERR. stdout is for data only — a listing, a JSON
+// document, logs being streamed — so `faable … --json | jq` and the MCP
+// server reading this CLI never get a progress line mixed into it.
+//
 // Tee: terminal stream (colorized) + a plain-text copy into the build-log
 // buffer so CLI messages land in the logs attached to the deployment.
 // What the terminal shows: just the message. pino's envelope
@@ -35,7 +39,14 @@ const toPlainText = prettyFactory({ colorize: false, sync: true });
 // NB: the two-arg form matters — pino(multistream) alone would treat the
 // multistream object as the options bag and log raw JSON to stdout.
 const log = pino({}, pino.multistream([
-    { stream: pretty({ colorize: true, sync: true, ...TERMINAL_FORMAT }) },
+    {
+        stream: pretty({
+            colorize: process.stderr.isTTY ?? false,
+            sync: true,
+            destination: 2,
+            ...TERMINAL_FORMAT,
+        }),
+    },
     {
         stream: {
             write(line) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "3.4.2",
+  "version": "4.0.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",

package/dist/commands/auth/paging.js

@@ -1,9 +0,0 @@
-const fetch_items = async (listing, all) => {
-    if (all) {
-        return { items: await listing.all(), more: false };
-    }
-    const page = await listing.pass();
-    return { items: page.results, more: !!page.next };
-};
-
-export { fetch_items };