@faable/faable 1.30.0 → 1.32.0

package/dist/commands/auth/logs/list.js

@@ -0,0 +1,90 @@
+import { withAuthHints, requireAuthAdmin } from '../../../api/auth_admin.js';
+import { log } from '../../../log.js';
+import { json_option, list_options, tenant_options } from '../options.js';
+import { fetch_items } from '../paging.js';
+import { compose_query, term, time_term } from '../query.js';
+import { print_json, log_status_badge, truncate, table_lines } from '../render.js';
+
+const logs_list = {
+    command: 'list',
+    describe: 'List and filter audit logs',
+    builder: yargs => json_option(list_options(tenant_options(yargs)))
+        .option('query', {
+        type: 'string',
+        description: 'Raw FaableQL filter (combined with the flags below)'
+    })
+        .option('q', {
+        type: 'string',
+        description: 'Full-text search over the log message'
+    })
+        .option('type', {
+        type: 'string',
+        description: 'Exact event type, e.g. admin.user.updated'
+    })
+        .option('status', {
+        type: 'string',
+        choices: ['success', 'failed', 'skipped', 'info'],
+        description: 'Event status'
+    })
+        .option('origin', {
+        type: 'string',
+        description: 'Subsystem prefix, e.g. oauth (matches oauth.*)'
+    })
+        .option('user', {
+        type: 'string',
+        description: 'Filter by subject user id'
+    })
+        .option('client', {
+        type: 'string',
+        description: 'Filter by subject client id'
+    })
+        .option('since', {
+        type: 'string',
+        description: 'From date: unix-millis or YYYY-MM-DD'
+    })
+        .option('until', {
+        type: 'string',
+        description: 'To date: unix-millis or YYYY-MM-DD'
+    })
+        .example('$0 auth logs list --user user_abc123 --since 2026-08-01', "One user's audit trail since August 1st")
+        .example('$0 auth logs list --origin oauth --status failed', 'Failed OAuth events')
+        .showHelpOnFail(false),
+    handler: withAuthHints(async (args) => {
+        const query = compose_query([
+            term('type', args.type),
+            term('status', args.status),
+            term('origin', args.origin),
+            term('user', args.user),
+            term('client', args.client),
+            time_term('since', args.since),
+            time_term('until', args.until)
+        ], args.query);
+        const api = await requireAuthAdmin(args);
+        const { items, more } = await fetch_items(api.logList({ query, q: args.q, pageSize: args.limit }), args.all);
+        if (args.json)
+            return print_json(items);
+        if (items.length === 0) {
+            log.info('📭 No audit log entries match.');
+            return;
+        }
+        log.info(`📜 ${items.length} entr${items.length === 1 ? 'y' : 'ies'}:`);
+        const rows = items.map(entry => [
+            entry.createdAt ?? '-',
+            entry.type ?? '-',
+            log_status_badge(entry.status),
+            typeof entry.user === 'string'
+                ? entry.user
+                : (entry.user?.id ?? '-'),
+            truncate(entry.message, 48),
+            entry.id ?? '-'
+        ]);
+        for (const line of table_lines(['DATE', 'TYPE', 'STATUS', 'USER', 'MESSAGE', 'ID'], rows)) {
+            log.info(`  ${line}`);
+        }
+        if (more) {
+            log.info('… more results available: raise --limit, use --all, or narrow with --since/--type.');
+        }
+    })
+};
+
+export { logs_list };

package/dist/commands/auth/options.js

@@ -0,0 +1,34 @@
+const tenant_options = (yargs) => yargs
+    .option('auth-url', {
+    type: 'string',
+    description: 'Auth tenant base URL, e.g. https://<account>.auth.faable.link (env FAABLE_AUTH_URL)'
+})
+    .option('account', {
+    type: 'string',
+    description: 'Resolve a different account id on the target host (env FAABLE_AUTH_ACCOUNT)'
+});
+const json_option = (yargs) => yargs.option('json', {
+    type: 'boolean',
+    default: false,
+    description: 'Output raw JSON (for scripting)'
+});
+const list_options = (yargs) => yargs
+    .option('limit', {
+    type: 'number',
+    default: 100,
+    description: 'Max items to fetch in one page (1-200)'
+})
+    .option('all', {
+    type: 'boolean',
+    default: false,
+    description: 'Fetch every page (ignores --limit)'
+})
+    .check(argv => {
+    const limit = argv.limit;
+    if (limit !== undefined && (!Number.isInteger(limit) || limit < 1 || limit > 200)) {
+        throw new Error('--limit must be an integer between 1 and 200');
+    }
+    return true;
+});
+
+export { json_option, list_options, tenant_options };

package/dist/commands/auth/paging.js

@@ -0,0 +1,9 @@
+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 };

package/dist/commands/auth/query.js

@@ -0,0 +1,36 @@
+// Pure helpers to compose FaableQL filter strings from CLI flags.
+//
+// FaableQL grammar (server-side, @faablecloud/faableql): space-separated
+// `field:value` terms, ANDed; values only allow [alnum _ - @ .], so a `:`
+// inside a value (e.g. an ISO-8601 timestamp) is a parse error — dates must be
+// unix-millis or YYYY-MM-DD.
+// Join flag-derived terms with a user-provided --query passthrough.
+const compose_query = (terms, passthrough) => {
+    const parts = terms.filter((t) => !!t);
+    if (passthrough?.trim())
+        parts.push(passthrough.trim());
+    return parts.length ? parts.join(' ') : undefined;
+};
+// Build a single `field:value` term, refusing values FaableQL cannot parse
+// (anything outside [alnum _ - @ .]) with a readable error instead of a
+// server-side 400.
+const term = (field, value) => {
+    if (value === undefined || value === '')
+        return undefined;
+    if (!/^[a-zA-Z0-9_\-@.]+$/.test(value)) {
+        throw new Error(`Invalid value for --${field}: "${value}" (allowed: letters, digits, _ - @ .)`);
+    }
+    return `${field}:${value}`;
+};
+// Validate a --since/--until value: unix-millis or YYYY-MM-DD. ISO timestamps
+// carry ':' which FaableQL rejects, so we fail fast with the fix.
+const time_term = (field, value) => {
+    if (value === undefined || value === '')
+        return undefined;
+    if (!/^\d+$/.test(value) && !/^\d{4}-\d{2}-\d{2}$/.test(value)) {
+        throw new Error(`Invalid --${field}: "${value}". Use unix-millis or YYYY-MM-DD (ISO timestamps with ':' are not supported)`);
+    }
+    return `${field}:${value}`;
+};
+
+export { compose_query, term, time_term };

package/dist/commands/auth/render.js

@@ -0,0 +1,48 @@
+// Pure rendering helpers for the `faable auth` read commands.
+const print_json = (data) => {
+    process.stdout.write(JSON.stringify(data, null, 2) + '\n');
+};
+// 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)];
+};
+const yes_no = (v) => (v ? '✓' : '-');
+const truncate = (s, max) => {
+    if (!s)
+        return '-';
+    const one_line = s.replace(/\s+/g, ' ').trim();
+    return one_line.length > max ? one_line.slice(0, max - 1) + '…' : one_line;
+};
+// Relative age, matching the deploy commands' `when` formatting.
+const when = (iso) => {
+    if (!iso)
+        return '-';
+    const ms = Date.now() - new Date(iso).getTime();
+    const minutes = Math.floor(ms / 60_000);
+    if (minutes < 1)
+        return 'just now';
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+};
+const STATUS_ICONS = {
+    success: '🟢',
+    info: '🔵',
+    skipped: '⚪',
+    failed: '🔴'
+};
+const log_status_badge = (status) => {
+    const s = status || 'info';
+    return `${STATUS_ICONS[s] ?? '⚪'} ${s}`;
+};
+
+export { log_status_badge, print_json, table_lines, truncate, when, yes_no };

package/dist/commands/auth/users/get.js

@@ -0,0 +1,42 @@
+import { withAuthHints, requireAuthAdmin } from '../../../api/auth_admin.js';
+import { log } from '../../../log.js';
+import { json_option, tenant_options } from '../options.js';
+import { print_json, yes_no, when } from '../render.js';
+
+const users_get = {
+    command: 'get <user_id>',
+    describe: 'Show a user',
+    builder: yargs => json_option(tenant_options(yargs))
+        .positional('user_id', {
+        type: 'string',
+        demandOption: true,
+        description: 'User identifier (user_…)'
+    })
+        .showHelpOnFail(false),
+    handler: withAuthHints(async (args) => {
+        const api = await requireAuthAdmin(args);
+        const user = await api.userGet(args.user_id);
+        if (args.json)
+            return print_json(user);
+        log.info(`👤 ${user.id}`);
+        log.info(`  Email:      ${user.email ?? '-'} (verified: ${yes_no(user.email_verified)})`);
+        log.info(`  Name:       ${user.name ?? '-'}`);
+        if (user.phone)
+            log.info(`  Phone:      ${user.phone}`);
+        if (user.country_iso)
+            log.info(`  Country:    ${user.country_iso}`);
+        log.info(`  Created:    ${user.createdAt ?? '-'}`);
+        log.info(`  Last login: ${user.last_login ? `${user.last_login} (${when(user.last_login)})` : '-'}${user.last_ip ? ` from ${user.last_ip}` : ''}`);
+        log.info(`  Logins:     ${user.logins_count ?? 0}`);
+        if (user.suspended) {
+            log.info(`  Suspended:  🔴 yes (${user.suspended_at ?? 'unknown date'})`);
+            if (user.suspended_reason)
+                log.info(`  Reason:     ${user.suspended_reason}`);
+        }
+        else {
+            log.info('  Suspended:  no');
+        }
+    })
+};
+
+export { users_get };

package/dist/commands/auth/users/ids.js

@@ -0,0 +1,45 @@
+// Resolve the target user ids for a bulk operation. Ids come from argv, from
+// stdin when none are given and input is piped (`… list --json | jq -r … |
+// faable auth users suspend`), or from a '-' placeholder. NB: yargs drops a
+// bare '-' from positionals, so piping with NO ids is the supported spelling;
+// '-' is still honored if it survives parsing. Dedupes, keeps order, and
+// rejects anything that doesn't look like a user id BEFORE any mutation runs.
+const wants_stdin = (args, is_tty) => args.includes('-') || (args.length === 0 && !is_tty);
+const parse_user_ids = (args, stdin) => {
+    const stdin_tokens = stdin === null ? null : stdin.split(/\s+/).filter(Boolean);
+    const raw = [];
+    let stdin_used = false;
+    for (const a of args) {
+        if (a === '-') {
+            if (stdin_tokens === null) {
+                throw new Error("'-' requires ids on stdin (one or more, whitespace-separated)");
+            }
+            raw.push(...stdin_tokens);
+            stdin_used = true;
+        }
+        else {
+            raw.push(a);
+        }
+    }
+    if (stdin_tokens !== null && !stdin_used) {
+        raw.push(...stdin_tokens);
+    }
+    const ids = [...new Set(raw)];
+    if (ids.length === 0) {
+        throw new Error('No user ids given (pass ids, or pipe them via stdin)');
+    }
+    const invalid = ids.filter(id => !/^user_[a-zA-Z0-9]+$/.test(id));
+    if (invalid.length > 0) {
+        throw new Error(`Invalid user id(s): ${invalid.join(', ')} (expected user_…)`);
+    }
+    return ids;
+};
+const read_stdin = async () => {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+};
+
+export { parse_user_ids, read_stdin, wants_stdin };

package/dist/commands/auth/users/index.js

@@ -0,0 +1,17 @@
+import { users_get } from './get.js';
+import { users_list } from './list.js';
+import { users_suspend } from './suspend.js';
+
+const users = {
+    command: 'users',
+    describe: 'List, inspect and suspend users',
+    builder: yargs => yargs
+        .command(users_list)
+        .command(users_get)
+        .command(users_suspend)
+        .demandCommand(1)
+        .showHelpOnFail(false),
+    handler: () => { }
+};
+
+export { users };

package/dist/commands/auth/users/list.js

@@ -0,0 +1,55 @@
+import { withAuthHints, requireAuthAdmin } from '../../../api/auth_admin.js';
+import { log } from '../../../log.js';
+import { json_option, list_options, tenant_options } from '../options.js';
+import { compose_query } from '../query.js';
+import { fetch_items } from '../paging.js';
+import { print_json, truncate, yes_no, when, table_lines } from '../render.js';
+
+const users_list = {
+    command: 'list',
+    describe: 'List and filter users',
+    builder: yargs => json_option(list_options(tenant_options(yargs)))
+        .option('query', {
+        type: 'string',
+        description: 'FaableQL filter, e.g. "suspended:true email_verified:false" (fields: email, name, phone, suspended, email_verified, country_iso, locale, last_ip)'
+    })
+        .option('q', {
+        type: 'string',
+        description: 'Full-text search over name/email/phone'
+    })
+        .option('suspended', {
+        type: 'boolean',
+        description: 'Only suspended users (shorthand for query suspended:true)'
+    })
+        .example('$0 auth users list --suspended', 'List suspended users')
+        .example('$0 auth users list --query email_verified:false --limit 50', 'First 50 unverified users')
+        .showHelpOnFail(false),
+    handler: withAuthHints(async (args) => {
+        const api = await requireAuthAdmin(args);
+        const query = compose_query([args.suspended !== undefined && `suspended:${args.suspended}`], args.query);
+        const { items, more } = await fetch_items(api.userList({ query, q: args.q, pageSize: args.limit }), args.all);
+        if (args.json)
+            return print_json(items);
+        if (items.length === 0) {
+            log.info('📭 No users match.');
+            return;
+        }
+        log.info(`👥 ${items.length} user(s):`);
+        const rows = items.map(u => [
+            u.id ?? '-',
+            truncate(u.email, 32),
+            truncate(u.name, 24),
+            yes_no(u.email_verified),
+            u.suspended ? '🔴 suspended' : '-',
+            when(u.last_login)
+        ]);
+        for (const line of table_lines(['ID', 'EMAIL', 'NAME', 'VERIFIED', 'SUSPENDED', 'LAST LOGIN'], rows)) {
+            log.info(`  ${line}`);
+        }
+        if (more) {
+            log.info('… more results available: raise --limit, use --all, or refine the filter.');
+        }
+    })
+};
+
+export { users_list };

package/dist/commands/auth/users/suspend.js

@@ -0,0 +1,87 @@
+import prompts from 'prompts';
+import { withAuthHints, requireAuthAdmin } from '../../../api/auth_admin.js';
+import { log } from '../../../log.js';
+import { json_option, tenant_options } from '../options.js';
+import { print_json } from '../render.js';
+import { wants_stdin, read_stdin, parse_user_ids } from './ids.js';
+
+const users_suspend = {
+    command: 'suspend [user_ids..]',
+    describe: 'Suspend one or more users (blocks logins, refresh tokens and sessions)',
+    builder: yargs => json_option(tenant_options(yargs))
+        .positional('user_ids', {
+        type: 'string',
+        array: true,
+        description: 'User ids (user_…); omit them to read ids from stdin'
+    })
+        .option('reason', {
+        alias: 'r',
+        type: 'string',
+        description: 'Suspension reason, recorded on the user (max 512 chars)'
+    })
+        .option('yes', {
+        alias: 'y',
+        type: 'boolean',
+        default: false,
+        description: 'Skip the confirmation prompt'
+    })
+        .example('$0 auth users suspend user_abc123 --reason "abuse: proxy payload"', 'Suspend one user')
+        .example('$0 auth users suspend user_a user_b user_c -y -r "abuse wave"', 'Suspend several users without prompting')
+        .example('faable auth users list --query email_verified:false --json | jq -r ".[].id" | $0 auth users suspend -y', 'Bulk-suspend ids piped from a filtered listing')
+        .showHelpOnFail(false),
+    handler: withAuthHints(async (args) => {
+        const argv_ids = args.user_ids ?? [];
+        const stdin = wants_stdin(argv_ids, !!process.stdin.isTTY)
+            ? await read_stdin()
+            : null;
+        const ids = parse_user_ids(argv_ids, stdin);
+        if (!args.yes) {
+            const preview = ids.slice(0, 5).join(', ') + (ids.length > 5 ? ', …' : '');
+            // In a non-TTY run without --yes, prompts resolves undefined → cancel.
+            const { confirm } = await prompts({
+                type: 'toggle',
+                name: 'confirm',
+                message: `Suspend ${ids.length} user(s) (${preview})?`,
+                initial: false,
+                active: 'yes',
+                inactive: 'no'
+            });
+            if (!confirm) {
+                log.info('Cancelled.');
+                return;
+            }
+        }
+        const api = await requireAuthAdmin(args);
+        const results = [];
+        for (const id of ids) {
+            try {
+                const user = await api.userUpdate(id, {
+                    suspended: true,
+                    ...(args.reason ? { suspended_reason: args.reason } : {})
+                });
+                results.push({ id, suspended: !!user.suspended });
+                // Progress lines stay off stdout in --json mode (machine-clean pipe).
+                if (!args.json) {
+                    log.info(`🔴 Suspended ${id}${user.email ? ` (${user.email})` : ''}`);
+                }
+            }
+            catch (e) {
+                const message = e instanceof Error ? e.message : String(e);
+                results.push({ id, suspended: false, error: message });
+                if (!args.json)
+                    log.error(`❌ Failed to suspend ${id}: ${message}`);
+            }
+        }
+        if (args.json)
+            print_json(results);
+        const failed = results.filter(r => r.error);
+        if (failed.length > 0) {
+            throw new Error(`${failed.length} of ${ids.length} suspension(s) failed${args.json ? '' : ' — see errors above'}`);
+        }
+        if (!args.json) {
+            log.info(`✅ ${ids.length} user(s) suspended. Live access tokens against external APIs remain valid until expiry (≤24h).`);
+        }
+    })
+};
+
+export { users_suspend };

package/dist/commands/deploy/index.js

@@ -19,7 +19,9 @@ import { is_superseded } from './superseded.js';
 
 const deploy = {
     command: 'deploy [app_id]',
-    describe: 'Deploy a faable app',
+    // Name the subcommand groups so `faable --help` makes them discoverable
+    // without digging into `faable deploy --help`.
+    describe: 'Deploy a faable app and manage it (secrets, domains, logs, deployments…)',
     builder: yargs => {
         // Product subcommands live under `deploy` (yargs matches them before the
         // app_id positional, so `faable deploy <app_id>` keeps working).

package/dist/commands/deploy/resolve_app_id.js

@@ -5,10 +5,11 @@ import { log } from '../../log.js';
 // app_id resolution (the user never has to look one up):
 //  1. explicit (positional on `deploy`, --app on subcommands)
 //  2. OIDC in CI — the backend resolves the app from the linked repository
-//  3. locally — the app saved by `faable deploy link` in faable.json
+//  3. locally — a legacy app_id in faable.json (older CLIs wrote it on
+//     `faable deploy link`; the current link only persists in the API)
 //  4. locally — the app whose linked repository matches the git origin remote
 //     of the working directory (repos are connected in the dashboard when the
-//     app is created, so most working copies never ran `link`)
+//     app is created, or via `faable deploy link`)
 const resolve_app_id = async (explicit, ctxAppId, api, workdir = process.cwd()) => {
     const app_id = explicit || ctxAppId || Configuration.instance().app_id;
     if (app_id)

package/dist/commands/link/index.js

@@ -1,7 +1,6 @@
 import { requireApi } from '../../api/context.js';
 import prompts from 'prompts';
 import { log } from '../../log.js';
-import { Configuration } from '../../lib/Configuration.js';
 import { getGitRemoteUrl } from '../../lib/git_remote.js';
 
 const DEPLOY_DOCS_URL = "https://faable.com/docs/deploy/github-actions";
@@ -27,9 +26,27 @@ const link = {
             log.warn('Passing an app_id to "faable link" is deprecated and ignored. ' +
                 'Just run "faable link" and select the app from the list.');
         }
-        const config = Configuration.instance();
-        if (config.app_id) {
-            log.info(`This repository is already linked to app: "${config.app_slug}" (${config.app_id})`);
+        log.info("Checking local git repository...");
+        const gitUrl = await getGitRemoteUrl(workdir);
+        if (!gitUrl) {
+            log.error("No git remote URL detected. Add a GitHub 'origin' remote and try again.");
+            return;
+        }
+        const { api } = await requireApi();
+        const apps = await api.list();
+        if (apps.length === 0) {
+            log.error("No apps found in your account. Create one first at https://faable.com");
+            return;
+        }
+        // The link lives in the API (app.repository) — every command resolves the
+        // app from the git remote, so nothing is written locally. Warn (and
+        // confirm) when the repository is already linked to an app.
+        const alreadyLinked = apps.filter((app) => app.repository === gitUrl);
+        if (alreadyLinked.length > 0) {
+            const names = alreadyLinked
+                .map((app) => `"${app.name}" (${app.id})`)
+                .join(", ");
+            log.info(`This repository is already linked to: ${names}`);
             const { relink } = await prompts({
                 type: "toggle",
                 name: "relink",
@@ -42,14 +59,6 @@ const link = {
                 return;
             }
         }
-        const { api } = await requireApi();
-        log.info("Checking local git repository...");
-        const gitUrl = await getGitRemoteUrl(workdir);
-        const apps = await api.list();
-        if (apps.length === 0) {
-            log.error("No apps found in your account. Create one first at https://faable.com");
-            return;
-        }
         const { selectedApp } = await prompts({
             type: "select",
             name: "selectedApp",
@@ -64,10 +73,6 @@ const link = {
             return;
         }
         log.info(`Linking to "${selectedApp.name}" (${selectedApp.id})...`);
-        if (!gitUrl) {
-            log.error("No git remote URL detected. Add a GitHub 'origin' remote and try again.");
-            return;
-        }
         // The API verifies that the user has a connected GitHub identity AND
         // access to the repository before persisting the link.
         let linked;
@@ -95,9 +100,6 @@ const link = {
             return;
         }
         log.info(`Linked repository ${gitUrl} to ${selectedApp.name}.`);
-        // Save locally for CLI convenience (only after the API confirms the link)
-        Configuration.instance().saveConfig({ app_slug: selectedApp.name, app_id: selectedApp.id });
-        log.info(`Successfully linked local repository to ${selectedApp.name}.`);
         // Deploy v4: push-to-deploy is server-side by default — no workflow to
         // scaffold. A repo that brings its own Faable workflow keeps deploying
         // through it (the API leaves the trigger on the Action in that case).

package/dist/index.js

@@ -1,5 +1,6 @@
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
+import { auth } from './commands/auth/index.js';
 import { deploy } from './commands/deploy/index.js';
 import { link_deprecated } from './commands/link/index.js';
 import { login } from './commands/login/index.js';
@@ -22,6 +23,10 @@ yg.scriptName('faable')
     if (banner_shown)
         return;
     banner_shown = true;
+    // --json mode is for piping: keep stdout machine-clean (no banner, no
+    // update-check notice).
+    if (argv.json)
+        return;
     log.info(`Faable CLI ${version}`);
     // `upgrade` does its own (forced) check
     if (argv._[0] !== 'upgrade') {
@@ -44,12 +49,17 @@ yg.scriptName('faable')
     }
 }, true)
     .command(deploy)
+    .command(auth)
     .command(login)
     .command(logout)
     .command(whoami)
     .command(upgrade)
     .command(link_deprecated)
     .demandCommand(1)
+    // Reject unknown (sub)commands loudly. Without this, a typo'd or
+    // not-yet-existing command (`faable secrets list` on a version where it
+    // lived elsewhere) exited silently with just the version banner.
+    .strictCommands()
     .help()
     .fail(function (msg, err) {
     if (err) {
@@ -58,8 +68,11 @@ yg.scriptName('faable')
         return;
     }
     if (msg) {
+        // Validation failure (unknown command, missing subcommand…): show the
+        // help, then fail red — a bad invocation must not exit 0.
         yg.showHelp();
-        log.info(msg);
+        log.error(`❌ ${msg}`);
+        process.exit(1);
     }
 })
     .parse(hideBin(process.argv), {});

package/dist/lib/Configuration.js

@@ -23,12 +23,6 @@ class Configuration {
             }
         }
     }
-    saveConfig(updates) {
-        this.config = { ...this.config, ...updates };
-        const config_path = path__default.join(process.cwd(), this.config_file);
-        fs.writeJSONSync(config_path, this.config, { spaces: 2 });
-        log.info(`Configuration saved to: ${this.config_file}`);
-    }
     static instance() {
         if (!Configuration._instance) {
             Configuration._instance = new Configuration();
@@ -58,9 +52,6 @@ class Configuration {
             next: this.config.next,
         };
     }
-    get app_slug() {
-        return this.config.app_slug;
-    }
     get app_id() {
         return this.config.app_id;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faable/faable",
-  "version": "1.30.0",
+  "version": "1.32.0",
   "main": "dist/index.js",
   "license": "MIT",
   "author": "Marc Pomar <marc@faable.com>",
@@ -27,6 +27,7 @@
   ],
   "dependencies": {
     "@actions/core": "^3.0.0",
+    "@faable/auth-sdk": "^2.5.18",
     "axios": "^1.18.1",
     "fs-extra": "^11.3.2",
     "handlebars": "^4.7.8",