@xano/cli 1.0.4-beta.1 → 1.0.4-beta.10

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/sandbox/pull/index.js

@@ -2,6 +2,7 @@ import { Flags } from '@oclif/core';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
 import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
+import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 export default class SandboxPull extends BaseCommand {
@@ -87,7 +88,6 @@ Pulled 42 documents from sandbox environment to ./my-sandbox
         }
         if (documents.length === 0) {
             this.log('No documents found in response');
-            return;
         }
         const outputDir = path.resolve(flags.directory);
         fs.mkdirSync(outputDir, { recursive: true });
@@ -182,7 +182,17 @@ Pulled 42 documents from sandbox environment to ./my-sandbox
             fs.writeFileSync(filePath, doc.content, 'utf8');
             writtenCount++;
         }
-        this.log(`Pulled ${writtenCount} documents from sandbox environment to ${flags.directory}`);
+        // ── Pull knowledge ────────────────────────────────────────────────────
+        const knowledgeUrl = `${profile.instance_origin}/api:meta/sandbox/knowledge/sync`;
+        const knowledgeObjects = await fetchKnowledge(knowledgeUrl, '', profile.access_token, this.verboseFetch.bind(this), flags.verbose);
+        let knowledgeCount = 0;
+        if (knowledgeObjects.length > 0) {
+            knowledgeCount = writeKnowledge(knowledgeObjects, outputDir);
+        }
+        const parts = [`${writtenCount} documents`];
+        if (knowledgeCount > 0)
+            parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
+        this.log(`Pulled ${parts.join(' + ')} from sandbox environment to ${flags.directory}`);
     }
     sanitizeFilename(name) {
         return snakeCase(name.replaceAll('"', ''));

package/dist/commands/sandbox/push/index.d.ts

@@ -19,6 +19,6 @@ export default class SandboxPush extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private openReview;
     private getFrontendUrl;
+    private openReview;
 }

package/dist/commands/sandbox/push/index.js

@@ -130,12 +130,29 @@ Push and open sandbox review in the browser
             branch: '',
             command: this,
             inputDir,
+            knowledge: {
+                listUrl: () => `${baseUrl}/knowledge/sync`,
+                rootDir: inputDir,
+            },
             verboseFetch: this.verboseFetch.bind(this),
         }, target, pushFlags);
         if (flags.review) {
             await this.openReview(profile.instance_origin, profile.access_token, flags.verbose);
         }
     }
+    getFrontendUrl(instanceOrigin) {
+        try {
+            const url = new URL(instanceOrigin);
+            if (url.hostname === 'localhost' || url.hostname === '127.0.0.1') {
+                url.port = '4200';
+                return url.origin;
+            }
+        }
+        catch {
+            // fall through
+        }
+        return instanceOrigin;
+    }
     async openReview(instanceOrigin, accessToken, verbose) {
         const response = await this.verboseFetch(`${instanceOrigin}/api:meta/sandbox/impersonate`, {
             headers: {
@@ -158,17 +175,4 @@ Push and open sandbox review in the browser
         this.log('Opening sandbox review...');
         await open(reviewUrl);
     }
-    getFrontendUrl(instanceOrigin) {
-        try {
-            const url = new URL(instanceOrigin);
-            if (url.hostname === 'localhost' || url.hostname === '127.0.0.1') {
-                url.port = '4200';
-                return url.origin;
-            }
-        }
-        catch {
-            // fall through
-        }
-        return instanceOrigin;
-    }
 }

package/dist/commands/static_host/build/push/index.d.ts

@@ -10,6 +10,7 @@ export default class StaticHostBuildPush extends BaseCommand {
         directory: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         file: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         name: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'no-gitignore': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         'no-wait': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         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>;
@@ -18,6 +19,5 @@ export default class StaticHostBuildPush extends BaseCommand {
         verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
     };
     run(): Promise<void>;
-    private countFiles;
     private createZipBuffer;
 }

package/dist/commands/static_host/build/push/index.js

@@ -3,6 +3,7 @@ import archiver from 'archiver';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import BaseCommand from '../../../../base-command.js';
+import { collectStaticHostFiles } from '../../../../utils/static-host-files.js';
 import { generateBuildName } from '../create/index.js';
 export default class StaticHostBuildPush extends BaseCommand {
     static args = {
@@ -27,6 +28,9 @@ ID: 124
         `$ xano static_host build push myhost -n "production" --description "Production build" -w 40
 Pushed 22 files as build "production"
 ID: 125
+`,
+        `$ xano static_host build push default -d ./static --no-gitignore
+Pushed 30 files as build "20260531-143022"
 `,
     ];
     static flags = {
@@ -52,6 +56,11 @@ ID: 125
             description: 'Build name (auto-generated from the current timestamp if omitted)',
             required: false,
         }),
+        'no-gitignore': Flags.boolean({
+            default: false,
+            description: 'Push every file in the directory, including those matched by .gitignore (the .git/ folder is always excluded)',
+            required: false,
+        }),
         'no-wait': Flags.boolean({
             default: false,
             description: 'Return immediately after upload instead of waiting for the build to finish',
@@ -113,10 +122,15 @@ ID: 125
             if (!dirStats.isDirectory()) {
                 this.error(`Path is not a directory: ${sourceDir}`);
             }
-            fileCount = this.countFiles(sourceDir);
+            const files = collectStaticHostFiles(sourceDir, { respectGitignore: !flags['no-gitignore'] });
+            if (files.length === 0) {
+                this.error(`No files to push from ${sourceDir} — everything is excluded by .gitignore. ` +
+                    `Use --no-gitignore to push the entire directory.`);
+            }
+            fileCount = files.length;
             if (animate)
                 ux.action.start('Packaging', `${fileCount} files`);
-            zipBuffer = await this.createZipBuffer(sourceDir);
+            zipBuffer = await this.createZipBuffer(sourceDir, files);
             if (animate) {
                 ux.action.stop(`${fileCount} files (${(zipBuffer.length / (1024 * 1024)).toFixed(1)} MB)`);
                 ux.action.start('Uploading');
@@ -192,20 +206,7 @@ ID: 125
             }
         }
     }
-    countFiles(dir) {
-        let count = 0;
-        const entries = fs.readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory()) {
-                count += this.countFiles(path.join(dir, entry.name));
-            }
-            else if (entry.isFile()) {
-                count++;
-            }
-        }
-        return count;
-    }
-    async createZipBuffer(sourceDir) {
+    async createZipBuffer(sourceDir, files) {
         return new Promise((resolve, reject) => {
             const chunks = [];
             const archive = archiver('zip', { zlib: { level: 9 } });
@@ -218,7 +219,9 @@ ID: 125
             archive.on('error', (err) => {
                 reject(err);
             });
-            archive.directory(sourceDir, false);
+            for (const rel of files) {
+                archive.file(path.join(sourceDir, rel), { name: rel });
+            }
             archive.finalize();
         });
     }

package/dist/commands/tenant/unit_test/run/index.d.ts

@@ -6,6 +6,7 @@ export default class TenantUnitTestRun extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
         output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         tenant: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         workspace: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;

package/dist/commands/tenant/unit_test/run/index.js

@@ -17,6 +17,11 @@ Result: PASS
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch the unit test belongs to (uses profile branch if not provided, then the live branch)',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -43,12 +48,14 @@ Result: PASS
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
         const tenantName = encodeURIComponent(flags.tenant);
+        const branch = flags.branch ?? profile.branch;
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/unit_test/${encodeURIComponent(args.unit_test_id)}/run`;
         try {
             if (flags.output === 'summary') {
                 this.log(`Running unit test ${args.unit_test_id}...`);
             }
             const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify(branch ? { branch } : {}),
                 headers: {
                     accept: 'application/json',
                     Authorization: `Bearer ${profile.access_token}`,

package/dist/commands/tenant/unit_test/run_all/index.js

@@ -18,7 +18,7 @@ Results: 4 passed, 1 failed
         ...BaseCommand.baseFlags,
         branch: Flags.string({
             char: 'b',
-            description: 'Filter by branch name',
+            description: 'Branch to run tests from (uses profile branch if not provided, then the live branch)',
             required: false,
         }),
         'obj-type': Flags.string({
@@ -53,11 +53,14 @@ Results: 4 passed, 1 failed
         }
         const tenantName = encodeURIComponent(flags.tenant);
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/tenant/${tenantName}/unit_test`;
+        // Resolve the branch once so the listed tests and the tests we run come
+        // from the same branch.
+        const branch = flags.branch ?? profile.branch;
         try {
             const listParams = new URLSearchParams();
             listParams.set('per_page', '10000');
-            if (flags.branch)
-                listParams.set('branch', flags.branch);
+            if (branch)
+                listParams.set('branch', branch);
             if (flags['obj-type'])
                 listParams.set('obj_type', flags['obj-type']);
             const listResponse = await this.verboseFetch(`${baseUrl}?${listParams}`, {
@@ -94,6 +97,7 @@ Results: 4 passed, 1 failed
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
+                        body: JSON.stringify(branch ? { branch } : {}),
                         headers: {
                             accept: 'application/json',
                             Authorization: `Bearer ${profile.access_token}`,

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

@@ -6,6 +6,7 @@ export default class UnitTestRun extends BaseCommand {
     static description: string;
     static examples: string[];
     static flags: {
+        branch: 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>;

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

@@ -14,9 +14,15 @@ Running unit test abc-123...
 Result: PASS
 `,
         `$ xano unit-test run abc-123 -o json`,
+        `$ xano unit-test run abc-123 --branch dev`,
     ];
     static flags = {
         ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch the unit test belongs to (uses profile branch if not provided, then the live branch)',
+            required: false,
+        }),
         output: Flags.string({
             char: 'o',
             default: 'summary',
@@ -37,12 +43,14 @@ Result: PASS
         if (!workspaceId) {
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
+        const branch = flags.branch ?? profile.branch;
         const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/unit_test/${args.unit_test_id}/run`;
         try {
             if (flags.output === 'summary') {
                 this.log(`Running unit test ${args.unit_test_id}...`);
             }
             const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify(branch ? { branch } : {}),
                 headers: {
                     'accept': 'application/json',
                     'Authorization': `Bearer ${profile.access_token}`,

package/dist/commands/unit_test/run_all/index.js

@@ -19,7 +19,7 @@ Results: 2 passed, 1 failed
         ...BaseCommand.baseFlags,
         branch: Flags.string({
             char: 'b',
-            description: 'Filter by branch name',
+            description: 'Branch to run tests from (uses profile branch if not provided, then the live branch)',
             required: false,
         }),
         'obj-type': Flags.string({
@@ -48,12 +48,15 @@ Results: 2 passed, 1 failed
             this.error('No workspace ID provided. Use --workspace flag or set one in your profile.');
         }
         const baseUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/unit_test`;
+        // Resolve the branch once so the listed tests and the tests we run come
+        // from the same branch.
+        const branch = flags.branch ?? profile.branch;
         try {
             // Step 1: List all unit tests
             const listParams = new URLSearchParams();
             listParams.set('per_page', '10000');
-            if (flags.branch) {
-                listParams.set('branch', flags.branch);
+            if (branch) {
+                listParams.set('branch', branch);
             }
             if (flags['obj-type']) {
                 listParams.set('obj_type', flags['obj-type']);
@@ -93,6 +96,7 @@ Results: 2 passed, 1 failed
                 const runUrl = `${baseUrl}/${test.id}/run`;
                 try {
                     const runResponse = await this.verboseFetch(runUrl, {
+                        body: JSON.stringify(branch ? { branch } : {}),
                         headers: {
                             accept: 'application/json',
                             Authorization: `Bearer ${profile.access_token}`,

package/dist/commands/workspace/pull/index.js

@@ -4,11 +4,12 @@ import * as path from 'node:path';
 import snakeCase from 'lodash.snakecase';
 import BaseCommand from '../../../base-command.js';
 import { buildApiGroupFolderResolver, parseDocument } from '../../../utils/document-parser.js';
+import { fetchKnowledge, writeKnowledge } from '../../../utils/knowledge-sync.js';
 export default class Pull extends BaseCommand {
     static description = 'Pull a workspace multidoc from the Xano Metadata API and split into individual files';
     static examples = [
         `$ xano workspace pull
-Pulled 42 documents to current directory
+Pulled 42 documents + 5 knowledge files to current directory
 `,
         `$ xano workspace pull -d ./my-workspace
 Pulled 42 documents to ./my-workspace
@@ -239,7 +240,17 @@ Pulled 58 documents
             fs.writeFileSync(filePath, doc.content, 'utf8');
             writtenCount++;
         }
-        this.log(`Pulled ${writtenCount} documents to ${flags.directory}`);
+        // ── Pull knowledge ────────────────────────────────────────────────────
+        const knowledgeUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/knowledge/sync`;
+        const knowledgeObjects = await fetchKnowledge(knowledgeUrl, branch, profile.access_token, this.verboseFetch.bind(this), flags.verbose);
+        let knowledgeCount = 0;
+        if (knowledgeObjects.length > 0) {
+            knowledgeCount = writeKnowledge(knowledgeObjects, outputDir);
+        }
+        const parts = [`${writtenCount} documents`];
+        if (knowledgeCount > 0)
+            parts.push(`${knowledgeCount} knowledge file${knowledgeCount === 1 ? '' : 's'}`);
+        this.log(`Pulled ${parts.join(' + ')} to ${flags.directory}`);
     }
     /**
      * Sanitize a document name for use as a filename.

package/dist/commands/workspace/push/index.d.ts

@@ -4,8 +4,8 @@ export default class Push extends BaseCommand {
     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>;
         delete: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        directory: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
         'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
         env: import("@oclif/core/interfaces").BooleanFlag<boolean>;
         exclude: import("@oclif/core/interfaces").OptionFlag<string[] | undefined, import("@oclif/core/interfaces").CustomOptions>;