@xano/cli 1.0.4 → 1.0.5

package/dist/commands/auth/index.js

@@ -6,9 +6,37 @@ import * as http from 'node:http';
 import { dirname } from 'node:path';
 import open from 'open';
 import { buildUserAgent, resolveCredentialsPath } from '../../base-command.js';
+function originHostname(value) {
+    try {
+        return new URL(value.includes('://') ? value : `https://${value}`).hostname.toLowerCase();
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Match a user-supplied --instance value against the instance list:
+ * numeric values match by ID, URL/hostname values match by the instance
+ * origin's hostname, anything else matches by name. Exported for tests.
+ */
+export function matchInstance(instances, query) {
+    const q = query.trim();
+    if (/^\d+$/.test(q)) {
+        return instances.find((inst) => inst.id === q);
+    }
+    if (q.includes('://') || q.includes('.')) {
+        const queryHost = originHostname(q);
+        const match = queryHost ? instances.find((inst) => originHostname(inst.origin) === queryHost) : undefined;
+        if (match) {
+            return match;
+        }
+    }
+    return instances.find((inst) => inst.name === q);
+}
 const AUTH_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
 export default class Auth extends Command {
     static description = 'Authenticate with Xano via browser login';
+    static enableJsonFlag = true;
     static examples = [
         `$ xano auth
 Opening browser for Xano login...
@@ -23,10 +51,24 @@ Opening browser for Xano login at https://custom.xano.com...`,
 To authenticate, open the following URL in any browser:
   https://app.xano.com/login?dest=cli&display=code
 ? Paste the code shown in your browser: ****`,
-        `$ echo "$CODE" | xano auth --no-browser
-(the code is read from piped stdin, no prompt at all)`,
+        `$ xano auth --code "$CODE" --instance https://my-instance.xano.io --workspace 5
+(fully non-interactive: no browser, no prompts; missing --branch/--profile fall back to defaults)`,
+        `$ echo "$CODE" | xano auth --no-browser --instance my-instance --workspace 5 --branch dev --profile staging
+(fully scripted: the code is read from piped stdin, no prompt at all)`,
+        `$ xano auth --code "$CODE" --instance 42 --workspace 5 --json
+(machine-readable: prints the created profile as JSON)`,
     ];
     static flags = {
+        branch: Flags.string({
+            char: 'b',
+            description: 'Pre-select a branch by label (skips the branch picker); pass "" to skip and use the live branch',
+            required: false,
+        }),
+        code: Flags.string({
+            description: 'Login code copied from the browser (implies --no-browser and runs fully non-interactively). Get the code at <origin>/login?dest=cli&display=code',
+            env: 'XANO_AUTH_CODE',
+            required: false,
+        }),
         config: Flags.string({
             char: 'c',
             description: 'Path to credentials file (default: ~/.xano/credentials.yaml)',
@@ -38,6 +80,11 @@ To authenticate, open the following URL in any browser:
             default: false,
             description: 'Skip TLS certificate verification (for self-signed certificates)',
         }),
+        instance: Flags.string({
+            char: 'i',
+            description: 'Pre-select an instance by name, numeric ID, or instance URL/hostname (skips the instance picker)',
+            required: false,
+        }),
         'no-browser': Flags.boolean({
             default: false,
             description: 'Headless login: print a URL and paste back the code shown in the browser, instead of starting a local callback server (use on remote/SSH/Docker hosts where 127.0.0.1 is not reachable from the browser)',
@@ -47,6 +94,16 @@ To authenticate, open the following URL in any browser:
             default: 'https://app.xano.com',
             description: 'Xano account origin URL',
         }),
+        profile: Flags.string({
+            char: 'p',
+            description: 'Profile name to save (skips the profile name prompt); pass "" to use the default name',
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Pre-select a workspace by ID or name (skips the workspace picker); pass "" to skip workspace',
+            required: false,
+        }),
     };
     async run() {
         const { flags } = await this.parse(Auth);
@@ -54,12 +111,13 @@ To authenticate, open the following URL in any browser:
             process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
             this.warn('TLS certificate verification is disabled (insecure mode)');
         }
+        // A supplied code (flag or env), piped stdin, or --json output means no
+        // prompt can ever open: every unanswered picker falls back to its default.
+        const nonInteractive = flags.code !== undefined || (flags['no-browser'] && !process.stdin.isTTY) || this.jsonEnabled();
         try {
-            // Step 1: Get token via browser auth
+            // Step 1: Get token via supplied code or browser auth
             this.log('Starting authentication flow...');
-            const token = flags['no-browser']
-                ? await this.promptForToken(flags.origin)
-                : await this.startAuthServer(flags.origin);
+            const token = await this.acquireToken(flags.code, flags['no-browser'], flags.origin);
             // Step 2: Validate token and get user info
             this.log('');
             this.log('Validating authentication...');
@@ -71,6 +129,9 @@ To authenticate, open the following URL in any browser:
             const isSelfHosted = !/^https:\/\/app\.(.*\.)?xano\.com$/.test(flags.origin);
             let instance;
             if (isSelfHosted) {
+                if (flags.instance) {
+                    this.warn('Ignoring --instance: the origin itself is the instance for self-hosted Xano.');
+                }
                 instance = {
                     display: flags.origin,
                     id: 'self-hosted',
@@ -85,31 +146,15 @@ To authenticate, open the following URL in any browser:
                 if (instances.length === 0) {
                     this.error('No instances found. Please check your account.');
                 }
-                instance = await this.selectInstance(instances);
-            }
-            // Step 4: Workspace selection
-            let workspace;
-            let branch;
-            this.log('');
-            this.log('Fetching available workspaces...');
-            const workspaces = await this.fetchWorkspaces(token, instance.origin);
-            if (workspaces.length > 0) {
-                workspace = await this.selectWorkspace(workspaces);
-                if (workspace) {
-                    // Step 5: Branch selection
-                    this.log('');
-                    this.log('Fetching available branches...');
-                    const branches = await this.fetchBranches(token, instance.origin, workspace.id);
-                    if (branches.length > 1) {
-                        branch = await this.selectBranch(branches);
-                    }
-                }
+                instance = await this.resolveInstance(instances, flags.instance, nonInteractive);
             }
+            // Steps 4 + 5: Workspace and branch selection
+            const { branch, workspace } = await this.resolveWorkspaceAndBranch(token, instance.origin, flags, nonInteractive);
             // Step 6: Profile name
             this.log('');
-            const profileName = await this.promptProfileName();
+            const profileName = await this.resolveProfileName(flags.profile, nonInteractive);
             // Step 7: Save profile
-            await this.saveProfile({
+            const credentialsPath = await this.saveProfile({
                 access_token: token,
                 account_origin: flags.origin,
                 branch,
@@ -120,6 +165,17 @@ To authenticate, open the following URL in any browser:
             }, flags.config);
             this.log('');
             this.log(`Profile '${profileName}' created successfully!`);
+            const result = {
+                branch: branch ?? null,
+                credentialsPath,
+                instance: { id: instance.id, name: instance.name, origin: instance.origin },
+                profile: profileName,
+                user: { email: user.email, id: user.id, name: user.name },
+                workspace: workspace ? { id: workspace.id, name: workspace.name } : null,
+            };
+            if (this.jsonEnabled()) {
+                this.logJson(result);
+            }
             // Ensure clean exit (the open() call can keep the event loop alive)
             process.exit(0);
         }
@@ -129,11 +185,33 @@ To authenticate, open the following URL in any browser:
             // @inquirer/core, so the thrown class won't match an imported one.
             if (error?.name === 'ExitPromptError') {
                 this.log('Authentication cancelled.');
-                return;
+                this.exit(0);
             }
             throw error;
         }
     }
+    // oclif's default toErrorJson serializes Error objects to {} (message is a
+    // non-enumerable property), leaving --json consumers with no error detail.
+    toErrorJson(err) {
+        const error = err;
+        return {
+            error: {
+                ...(error.code ? { code: error.code } : {}),
+                message: error.message ?? String(err),
+                ...(error.suggestions?.length ? { suggestions: error.suggestions } : {}),
+            },
+        };
+    }
+    async acquireToken(code, noBrowser, origin) {
+        if (code !== undefined) {
+            const token = code.trim();
+            if (token === '') {
+                this.error(`No code provided. Copy it from ${origin}/login?dest=cli&display=code and pass it via --code or XANO_AUTH_CODE.`);
+            }
+            return token;
+        }
+        return noBrowser ? this.promptForToken(origin) : this.startAuthServer(origin);
+    }
     getHeaders(accessToken) {
         return {
             'User-Agent': buildUserAgent(this.config.version),
@@ -181,7 +259,7 @@ To authenticate, open the following URL in any browser:
         if (Array.isArray(data)) {
             return data.map((inst) => ({
                 display: inst.display,
-                id: inst.id || inst.name,
+                id: String(inst.id ?? inst.name),
                 name: inst.name,
                 origin: new URL(inst.meta_api).origin,
             }));
@@ -278,6 +356,95 @@ To authenticate, open the following URL in any browser:
             process.stdin.on('error', () => resolve(data.trim()));
         });
     }
+    async resolveBranch(branches, flagValue, nonInteractive) {
+        if (flagValue !== undefined) {
+            // An empty value means "skip and use live branch" (same as the picker's skip option)
+            if (flagValue.trim() === '') {
+                this.log('Using live branch');
+                return undefined;
+            }
+            const match = branches.find((br) => br.label === flagValue || br.id === flagValue);
+            if (!match) {
+                this.error(`Branch '${flagValue}' not found. Available branches: ${branches.map((br) => br.label).join(', ')}`);
+            }
+            this.log(`Using branch: ${match.label}`);
+            return match.id;
+        }
+        if (nonInteractive) {
+            this.log('Using live branch (non-interactive; pass --branch to select one)');
+            return undefined;
+        }
+        return branches.length > 1 ? this.selectBranch(branches) : undefined;
+    }
+    async resolveInstance(instances, flagValue, nonInteractive) {
+        if (flagValue) {
+            const match = matchInstance(instances, flagValue);
+            if (!match) {
+                this.error(`Instance '${flagValue}' not found (match by name, numeric ID, or instance URL). Available instances: ${instances.map((inst) => `${inst.name} (${inst.id})`).join(', ')}`);
+            }
+            this.log(`Using instance: ${match.name} (${match.display})`);
+            return match;
+        }
+        if (nonInteractive) {
+            if (instances.length === 1) {
+                this.log(`Using instance: ${instances[0].name} (${instances[0].display})`);
+                return instances[0];
+            }
+            this.error(`Multiple instances available; pass --instance to select one. Available instances: ${instances.map((inst) => `${inst.name} (${inst.id})`).join(', ')}`);
+        }
+        return this.selectInstance(instances);
+    }
+    async resolveProfileName(flagValue, nonInteractive) {
+        // An empty --profile value means "use the default name" (same as accepting the prompt's default);
+        // non-interactive runs with no --profile fall back to the default name too.
+        if (flagValue !== undefined) {
+            return flagValue.trim() || 'default';
+        }
+        return nonInteractive ? 'default' : this.promptProfileName();
+    }
+    async resolveWorkspace(workspaces, flagValue, nonInteractive) {
+        if (flagValue !== undefined) {
+            // An empty value means "skip workspace" (same as the picker's skip option)
+            if (flagValue.trim() === '') {
+                this.log('Skipping workspace selection');
+                return undefined;
+            }
+            const match = workspaces.find((ws) => String(ws.id) === flagValue || ws.name === flagValue);
+            if (!match) {
+                this.error(`Workspace '${flagValue}' not found. Available workspaces: ${workspaces.map((ws) => `${ws.name} (${ws.id})`).join(', ')}`);
+            }
+            this.log(`Using workspace: ${match.name} (${match.id})`);
+            return match;
+        }
+        if (nonInteractive) {
+            this.log('Skipping workspace selection (non-interactive; pass --workspace to select one)');
+            return undefined;
+        }
+        return this.selectWorkspace(workspaces);
+    }
+    async resolveWorkspaceAndBranch(token, instanceOrigin, flags, nonInteractive) {
+        let workspace;
+        let branch;
+        this.log('');
+        this.log('Fetching available workspaces...');
+        const workspaces = await this.fetchWorkspaces(token, instanceOrigin);
+        if (workspaces.length > 0) {
+            workspace = await this.resolveWorkspace(workspaces, flags.workspace, nonInteractive);
+            if (workspace) {
+                this.log('');
+                this.log('Fetching available branches...');
+                const branches = await this.fetchBranches(token, instanceOrigin, workspace.id);
+                branch = await this.resolveBranch(branches, flags.branch, nonInteractive);
+            }
+        }
+        else if (flags.workspace) {
+            this.error(`Workspace '${flags.workspace}' not found: no workspaces are available on this instance.`);
+        }
+        if (flags.branch && !workspace) {
+            this.warn('Ignoring --branch: no workspace selected.');
+        }
+        return { branch, workspace };
+    }
     async saveProfile(profile, configPath) {
         const credentialsPath = resolveCredentialsPath(configPath);
         const credDir = dirname(credentialsPath);
@@ -317,6 +484,7 @@ To authenticate, open the following URL in any browser:
             noRefs: true,
         });
         fs.writeFileSync(credentialsPath, yamlContent, 'utf8');
+        return credentialsPath;
     }
     async selectBranch(branches) {
         const { selectedBranch } = await inquirer.prompt([

package/dist/commands/function/run/index.d.ts

@@ -0,0 +1,40 @@
+import BaseCommand from '../../../base-command.js';
+export default class FunctionRun extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        data: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        json: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        logs: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-input-check': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        stdin: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private emitResult;
+    /**
+     * Fetch a single function record by name via the list endpoint's search,
+     * returning the exact-name match (so `calc` doesn't accidentally match
+     * `calcScore`). Best-effort: returns undefined and warns on any failure so a
+     * transient introspection problem never blocks an otherwise-valid run.
+     */
+    private fetchFunctionByName;
+    /**
+     * Prompt for each missing required input on an interactive TTY. Values are
+     * read as raw JSON when they parse as such (so numbers/bools/objects work),
+     * otherwise treated as a string — mirroring the `key:=`/`key=` distinction.
+     * Non-TTY: fail fast with the list of missing params (never hang on a prompt).
+     */
+    private promptForMissing;
+    private readStdinSync;
+    private resolveWorkspaceId;
+}

package/dist/commands/function/run/index.js

@@ -0,0 +1,244 @@
+import { Args, Flags } from '@oclif/core';
+import { readFileSync } from 'node:fs';
+import BaseCommand from '../../../base-command.js';
+import { assembleInput, loadJsonSource, parseDataPairs, validateAgainstSchema, } from '../../../utils/function-input.js';
+export default class FunctionRun extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Name of the function to run (interactive if omitted with --name unset)',
+            required: false,
+        }),
+    };
+    static description = 'Run (execute) a named function in a workspace and print its result';
+    static examples = [
+        `$ xano function:run calcScore -w 40
+# Prompts for any declared inputs, then runs the function`,
+        `$ xano function:run calcScore --data email=jo@x.com --data age:=30 --data active:=true`,
+        `$ xano function:run calcScore --json @payload.json --data env=staging`,
+        `$ echo '{"email":"jo@x.com"}' | xano function:run calcScore --stdin -o json | jq .result`,
+        `$ xano function:run calcScore --branch dev --logs`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            description: 'Branch to run from (defaults to profile branch, then main)',
+            required: false,
+        }),
+        data: Flags.string({
+            char: 'd',
+            description: 'Input field as key=value (string), key:=json (raw JSON), or key@file (file contents). Repeatable.',
+            multiple: true,
+            required: false,
+        }),
+        json: Flags.string({
+            description: "Input as a JSON object: inline, @file.json, or '-' for stdin",
+            exclusive: ['stdin'],
+            required: false,
+        }),
+        logs: Flags.boolean({
+            default: false,
+            description: 'Print the execution logs returned by the debugger',
+            required: false,
+        }),
+        'name': Flags.string({
+            char: 'n',
+            description: 'Name of the function to run (alternative to the positional argument)',
+            required: false,
+        }),
+        'no-input-check': Flags.boolean({
+            default: false,
+            description: 'Skip local schema validation and interactive prompting; send the payload as-is',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'json',
+            description: 'Output format',
+            options: ['json', 'summary'],
+            required: false,
+        }),
+        stdin: Flags.boolean({
+            char: 's',
+            default: false,
+            description: "Read the input JSON object from stdin (same as --json -)",
+            exclusive: ['json'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(FunctionRun);
+        const { profile, profileName } = this.resolveProfile(flags);
+        const functionName = args.name ?? flags.name;
+        if (!functionName) {
+            this.error('A function name is required. Provide it as an argument or with --name.');
+        }
+        const workspaceId = this.resolveWorkspaceId(flags, profile, profileName);
+        const branch = flags.branch ?? profile.branch ?? '';
+        // 1) Assemble the input object from JSON base + --data overrides.
+        const jsonSource = flags.stdin ? '-' : flags.json;
+        const jsonBase = loadJsonSource(jsonSource, { stdin: () => this.readStdinSync() });
+        let input = assembleInput({ dataPairs: parseDataPairs(flags.data ?? []), jsonBase });
+        // 2) Introspect the function's declared inputs (best-effort) to validate,
+        //    warn on obvious mismatches, and prompt for missing required params.
+        if (!flags['no-input-check']) {
+            const fn = await this.fetchFunctionByName({
+                branch,
+                name: functionName,
+                profile,
+                verbose: flags.verbose,
+                workspaceId,
+            });
+            const schema = fn?.input;
+            const { missingRequired, warnings } = validateAgainstSchema(input, schema);
+            for (const w of warnings)
+                this.warn(w);
+            if (missingRequired.length > 0) {
+                input = await this.promptForMissing(input, missingRequired);
+            }
+        }
+        // 3) Execute via the meta run endpoint.
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function/run`;
+        const body = { input, name: functionName };
+        if (branch)
+            body.branch = branch;
+        const response = await this.verboseFetch(apiUrl, {
+            body: JSON.stringify(body),
+            headers: {
+                'accept': 'application/json',
+                'Authorization': `Bearer ${profile.access_token}`,
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        }, flags.verbose, profile.access_token);
+        if (!response.ok) {
+            const message = await this.parseApiError(response, 'Failed to run function');
+            this.error(message);
+        }
+        const result = (await response.json());
+        this.emitResult(result, flags.output, flags.logs);
+        // 4) Compose in scripts/CI: non-zero exit when the function errored.
+        if (result.status && result.status !== 'ok') {
+            this.exit(1);
+        }
+    }
+    emitResult(result, output, showLogs) {
+        if (output === 'json') {
+            // Raw result object so `| jq .result` works predictably.
+            this.log(JSON.stringify(result.result ?? null, null, 2));
+        }
+        else {
+            const status = result.status ?? 'ok';
+            this.log(`Status: ${status}`);
+            this.log('Result:');
+            this.log(JSON.stringify(result.result ?? null, null, 2));
+        }
+        if (showLogs && Array.isArray(result.logs) && result.logs.length > 0) {
+            this.log('');
+            this.log('Logs:');
+            for (const entry of result.logs) {
+                this.log(typeof entry === 'string' ? entry : JSON.stringify(entry));
+            }
+        }
+    }
+    /**
+     * Fetch a single function record by name via the list endpoint's search,
+     * returning the exact-name match (so `calc` doesn't accidentally match
+     * `calcScore`). Best-effort: returns undefined and warns on any failure so a
+     * transient introspection problem never blocks an otherwise-valid run.
+     */
+    async fetchFunctionByName(opts) {
+        const { branch, name, profile, verbose, workspaceId } = opts;
+        // eslint-disable-next-line camelcase -- external Metadata API query param
+        const params = new URLSearchParams({ per_page: '100', search: name });
+        if (branch)
+            params.set('branch', branch);
+        const url = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/function?${params.toString()}`;
+        try {
+            const response = await this.verboseFetch(url, { headers: { accept: 'application/json', Authorization: `Bearer ${profile.access_token}` }, method: 'GET' }, verbose, profile.access_token);
+            if (!response.ok)
+                return undefined;
+            const page = (await response.json());
+            const items = Array.isArray(page) ? page : (page.items ?? []);
+            const exact = items.filter((f) => f.name === name);
+            if (exact.length > 1) {
+                this.warn(`Multiple functions named '${name}' found; skipping input validation.`);
+                return undefined;
+            }
+            return exact[0];
+        }
+        catch {
+            // Introspection is a convenience, not a requirement.
+            return undefined;
+        }
+    }
+    /**
+     * Prompt for each missing required input on an interactive TTY. Values are
+     * read as raw JSON when they parse as such (so numbers/bools/objects work),
+     * otherwise treated as a string — mirroring the `key:=`/`key=` distinction.
+     * Non-TTY: fail fast with the list of missing params (never hang on a prompt).
+     */
+    async promptForMissing(input, missing) {
+        if (!process.stdout.isTTY || !process.stdin.isTTY) {
+            const names = missing.map((p) => `${p.name}${p.type ? ` (${p.type})` : ''}`).join(', ');
+            this.error(`Missing required input: ${names}. ` +
+                `Provide via --data/--json, or run interactively in a terminal.`);
+        }
+        const readline = await import('node:readline');
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        const ask = (message) => new Promise((resolve) => {
+            rl.question(message, resolve);
+        });
+        const filled = { ...input };
+        try {
+            for (const param of missing) {
+                const hint = [param.type, param.description].filter(Boolean).join(' — ');
+                // eslint-disable-next-line no-await-in-loop
+                const raw = await ask(`${param.name}${hint ? ` (${hint})` : ''}: `);
+                filled[param.name] = coercePromptValue(raw, param);
+            }
+        }
+        finally {
+            rl.close();
+        }
+        return filled;
+    }
+    readStdinSync() {
+        // Synchronous read of all of stdin (fd 0); used for --json - / --stdin.
+        try {
+            return readFileSync(0, 'utf8');
+        }
+        catch (error) {
+            this.error(`Failed to read from stdin: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    resolveWorkspaceId(flags, profile, profileName) {
+        if (flags.workspace)
+            return flags.workspace;
+        if (profile.workspace)
+            return profile.workspace;
+        this.error(`Workspace ID is required. Either:\n` +
+            `  1. Provide it as a flag: xano function:run <name> -w <workspace_id>\n` +
+            `  2. Set it in your profile using: xano profile:edit ${profileName} -w <workspace_id>`);
+    }
+}
+/**
+ * Coerce a prompted string into the value the parameter likely expects. Non-text
+ * params attempt a JSON parse (so `30`, `true`, `["a"]` become typed values);
+ * text params keep the raw string. Falls back to the raw string on parse errors.
+ */
+function coercePromptValue(raw, param) {
+    const isTextLike = !param.type || param.type === 'text' || param.type === 'uuid';
+    if (isTextLike)
+        return raw;
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return raw;
+    }
+}

package/dist/commands/knowledge/{pull → get}/index.d.ts

@@ -1,10 +1,14 @@
 import BaseCommand from '../../../base-command.js';
-export default class KnowledgePull extends BaseCommand {
+export default class KnowledgeGet extends BaseCommand {
+    static args: {
+        name: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
     static description: string;
     static examples: string[];
     static flags: {
         branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
-        directory: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         profile: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;