@xano/cli 1.0.4-beta.9 → 1.0.5

package/README.md

@@ -284,6 +284,31 @@ when the function returns an error status.
 > denied with an access error — grant run/debug to the role (or use a token whose role has
 > it). `function list`/`get`/`create`/`edit` only need the Function permission.
 
+### Knowledge
+
+```bash
+# List all enabled knowledge as markdown (always-on items show full content, on-demand show name + description)
+xano knowledge list -w 40
+
+# List as JSON
+xano knowledge list -w 40 --output json
+
+# Filter by knowledge type (skill, doc, agents.md)
+xano knowledge list -w 40 --type skill
+
+# Include disabled items
+xano knowledge list --no-enabled-only
+
+# Get a specific knowledge item's content by name
+xano knowledge get "deploy-runbook" -w 40
+
+# Get as JSON (includes all metadata)
+xano knowledge get "deploy-runbook" -w 40 --output json
+
+# Get a reference file attached to a knowledge item
+xano knowledge get "deploy-runbook" -w 40 --file checklist.md
+```
+
 ### Releases
 
 All release commands use **release names** (e.g., `v1.0`), not IDs.

package/dist/commands/knowledge/get/index.d.ts

@@ -0,0 +1,18 @@
+import BaseCommand from '../../../base-command.js';
+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>;
+        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>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+}

package/dist/commands/knowledge/get/index.js

@@ -0,0 +1,126 @@
+import { Args, Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class KnowledgeGet extends BaseCommand {
+    static args = {
+        name: Args.string({
+            description: 'Knowledge item name',
+            required: true,
+        }),
+    };
+    static description = 'Get a knowledge item by name, or one of its reference files';
+    static examples = [
+        '$ xano knowledge get "deploy-runbook" -w 40',
+        '$ xano knowledge get "deploy-runbook" -w 40 --output json',
+        '$ xano knowledge get "deploy-runbook" -w 40 --file checklist.md',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch ID',
+            required: false,
+        }),
+        file: Flags.string({
+            char: 'f',
+            description: 'Path of a reference file to fetch instead of the main content',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'text',
+            description: 'Output format',
+            options: ['text', '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(KnowledgeGet);
+        const { profile, profileName } = this.resolveProfile(flags);
+        let workspaceId;
+        if (flags.workspace) {
+            workspaceId = flags.workspace;
+        }
+        else if (profile.workspace) {
+            workspaceId = profile.workspace;
+        }
+        else {
+            this.error(`Workspace ID is required. Either:\n` +
+                `  1. Provide it as a flag: xano knowledge get <name> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        const queryParams = new URLSearchParams();
+        queryParams.set('enabled_only', 'false');
+        queryParams.set('include_content', 'true');
+        if (flags.branch) {
+            queryParams.set('branch_id', flags.branch);
+        }
+        const listUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/knowledge?${queryParams.toString()}`;
+        try {
+            const listResponse = await this.verboseFetch(listUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                method: 'GET',
+            }, flags.verbose, profile.access_token);
+            if (!listResponse.ok) {
+                const errorText = await listResponse.text();
+                this.error(`API request failed with status ${listResponse.status}: ${listResponse.statusText}\n${errorText}`);
+            }
+            const data = await listResponse.json();
+            const items = Array.isArray(data) ? data : (data.items ?? []);
+            const targetName = args.name.toLowerCase();
+            const item = items.find((i) => i.name?.toLowerCase() === targetName);
+            if (!item) {
+                const available = items.map((i) => i.name).filter(Boolean).join(', ');
+                this.error(`Knowledge item not found: "${args.name}"\n` +
+                    (available ? `Available items: ${available}` : 'No knowledge items exist in this workspace.'));
+            }
+            if (flags.file) {
+                const fileParams = new URLSearchParams({ path: flags.file });
+                const fileUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/knowledge/${item.id}/file?${fileParams.toString()}`;
+                const fileResponse = await this.verboseFetch(fileUrl, {
+                    headers: {
+                        'accept': 'application/json',
+                        'Authorization': `Bearer ${profile.access_token}`,
+                    },
+                    method: 'GET',
+                }, flags.verbose, profile.access_token);
+                if (!fileResponse.ok) {
+                    const errorText = await fileResponse.text();
+                    this.error(`Failed to fetch file "${flags.file}" from knowledge item "${item.name}": ${fileResponse.status} ${fileResponse.statusText}\n${errorText}`);
+                }
+                const fileJson = await fileResponse.json();
+                const fileContent = fileJson.file?.content ?? '';
+                if (flags.output === 'json') {
+                    this.log(JSON.stringify({ content: fileContent, name: item.name, path: flags.file }, null, 2));
+                }
+                else {
+                    this.log(fileContent);
+                }
+                return;
+            }
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(item, null, 2));
+            }
+            else {
+                this.log(item.content ?? '');
+            }
+        }
+        catch (error) {
+            if (error instanceof Error && 'oclif' in error)
+                throw error;
+            if (error instanceof Error) {
+                this.error(`Failed to fetch knowledge: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to fetch knowledge: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/knowledge/list/index.d.ts

@@ -0,0 +1,18 @@
+import BaseCommand from '../../../base-command.js';
+export default class KnowledgeList extends BaseCommand {
+    static args: {};
+    static description: string;
+    static examples: string[];
+    static flags: {
+        branch: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'enabled-only': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        output: import("@oclif/core/interfaces").OptionFlag<string, import("@oclif/core/interfaces").CustomOptions>;
+        type: import("@oclif/core/interfaces").OptionFlag<string | undefined, 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>;
+        verbose: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+    };
+    run(): Promise<void>;
+    private formatMarkdown;
+}

package/dist/commands/knowledge/list/index.js

@@ -0,0 +1,135 @@
+import { Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class KnowledgeList extends BaseCommand {
+    static args = {};
+    static description = 'List workspace knowledge and skills as plain-text markdown';
+    static examples = [
+        `$ xano knowledge list -w 40
+# Always-on Knowledge
+
+## deploy-runbook
+
+# Deploy Runbook
+...
+
+# On-demand Knowledge
+
+- **code-style**: Our team coding conventions
+`,
+        '$ xano knowledge list -w 40 --output json',
+        '$ xano knowledge list -w 40 --type skill',
+        '$ xano knowledge list --no-enabled-only',
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        branch: Flags.string({
+            char: 'b',
+            description: 'Branch ID',
+            required: false,
+        }),
+        'enabled-only': Flags.boolean({
+            allowNo: true,
+            default: true,
+            description: 'Only show enabled knowledge (use --no-enabled-only to include disabled)',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'markdown',
+            description: 'Output format',
+            options: ['markdown', 'json'],
+            required: false,
+        }),
+        type: Flags.string({
+            char: 't',
+            description: 'Filter by knowledge type',
+            options: ['skill', 'doc', 'agents.md'],
+            required: false,
+        }),
+        workspace: Flags.string({
+            char: 'w',
+            description: 'Workspace ID (optional if set in profile)',
+            required: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(KnowledgeList);
+        const { profile, profileName } = this.resolveProfile(flags);
+        let workspaceId;
+        if (flags.workspace) {
+            workspaceId = flags.workspace;
+        }
+        else if (profile.workspace) {
+            workspaceId = profile.workspace;
+        }
+        else {
+            this.error(`Workspace ID is required. Either:\n` +
+                `  1. Provide it as a flag: xano knowledge list -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        const queryParams = new URLSearchParams();
+        queryParams.set('enabled_only', flags['enabled-only'].toString());
+        queryParams.set('include_content', 'true');
+        if (flags.branch) {
+            queryParams.set('branch_id', flags.branch);
+        }
+        if (flags.type) {
+            queryParams.set('type', flags.type);
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/knowledge?${queryParams.toString()}`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                },
+                method: 'GET',
+            }, flags.verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text();
+                this.error(`API request failed with status ${response.status}: ${response.statusText}\n${errorText}`);
+            }
+            const data = await response.json();
+            const items = Array.isArray(data) ? data : (data.items ?? []);
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(items, null, 2));
+                return;
+            }
+            this.log(this.formatMarkdown(items));
+        }
+        catch (error) {
+            if (error instanceof Error && 'oclif' in error)
+                throw error;
+            if (error instanceof Error) {
+                this.error(`Failed to fetch knowledge: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to fetch knowledge: ${String(error)}`);
+            }
+        }
+    }
+    formatMarkdown(items) {
+        if (items.length === 0) {
+            return 'No knowledge items found.';
+        }
+        const alwaysOn = items.filter((item) => item.mode === 'always');
+        const onDemand = items.filter((item) => item.mode !== 'always');
+        const lines = [];
+        if (alwaysOn.length > 0) {
+            lines.push('# Always-on Knowledge');
+            for (const item of alwaysOn) {
+                lines.push('', `## ${item.name ?? '(unnamed)'}`, '', item.content ?? '', '', '---');
+            }
+        }
+        if (onDemand.length > 0) {
+            if (lines.length > 0)
+                lines.push('');
+            lines.push('# On-demand Knowledge', '');
+            for (const item of onDemand) {
+                const desc = item.description || '(no description)';
+                lines.push(`- **${item.name ?? '(unnamed)'}**: ${desc}`);
+            }
+        }
+        return lines.join('\n');
+    }
+}

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

@@ -5,7 +5,7 @@ import open from 'open';
 import BaseCommand from '../../../base-command.js';
 import { executePush } from '../../../utils/multidoc-push.js';
 export default class SandboxPush extends BaseCommand {
-    static description = '[IMPORTANT] ALWAYS run --dry-run first and show the user the output before pushing. Push local documents to your sandbox environment via multidoc import. By default, only changed files are pushed (partial mode). Use --sync to push all files. Shows a preview of changes before pushing unless --force is specified. Use --dry-run to preview only. Include/exclude glob filters are intentionally not supported on sandbox push — partial pushes can hide deletions during review and lead to data loss when promoted to the workspace. Large pushes against a sandbox loaded with a different workspace will prompt for confirmation; run `xano sandbox reset` first to start clean.';
+    static description = '[IMPORTANT] ALWAYS run --dry-run first and show the user the output before pushing. Push local documents to your sandbox environment via multidoc import. By default, only changed files are pushed (partial mode). Use --sync to push all files. Shows a preview of changes before pushing unless --force is specified. Use --dry-run to preview only. Include/exclude glob filters are intentionally not supported on sandbox push — partial pushes can hide deletions during review and lead to data loss when promoted to the workspace. Pushing into a sandbox that currently holds a different workspace will prompt for confirmation; run `xano sandbox reset` first to start clean.';
     static examples = [
         `$ xano sandbox push
 Push from current directory (default partial mode)
@@ -109,6 +109,7 @@ Push and open sandbox review in the browser
             cliVersion: this.config.version,
             instanceOrigin: profile.instance_origin,
             label: 'sandbox environment',
+            sourceWorkspaceId: profile.workspace,
             supportsBranches: false,
             supportsPartial: true,
             warnOnWorkspaceMismatch: true,

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

@@ -1,5 +1,6 @@
 import { Flags } from '@oclif/core';
 import BaseCommand from '../../../base-command.js';
+import { pushKnowledge } from '../../../utils/knowledge-sync.js';
 export default class SandboxReset extends BaseCommand {
     static description = '[CRITICAL] NEVER run without explicit user confirmation; this clears all workspace data and drafts. Resets your sandbox environment.';
     static examples = [
@@ -42,6 +43,17 @@ Sandbox environment has been reset.
                 const message = await this.parseApiError(response, 'API request failed');
                 this.error(message);
             }
+            try {
+                const knowledgeUrl = `${profile.instance_origin}/api:meta/sandbox/knowledge/sync`;
+                await pushKnowledge(knowledgeUrl, profile.access_token, this.verboseFetch.bind(this), flags.verbose, {
+                    delete: true,
+                    force: true,
+                    items: [],
+                });
+            }
+            catch (error) {
+                this.warn(`Sandbox environment was reset, but clearing knowledge files failed: ${error instanceof Error ? error.message : String(error)}`);
+            }
             this.log('Sandbox environment has been reset.');
         }
         catch (error) {

package/dist/utils/knowledge-sync.js

@@ -12,7 +12,7 @@ import { dirname, join, relative, sep } from 'node:path';
 // let the server dictate file paths.
 export const KNOWLEDGE_DIR = 'knowledge';
 // ── Frontmatter ──────────────────────────────────────────────────────────────
-const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'scope', 'mode', 'enabled', 'guid'];
+const FRONTMATTER_ORDER = ['name', 'description', 'knowledge_type', 'scope', 'inclusion', 'enabled', 'guid'];
 /**
  * Build a primary `.md` file body: YAML frontmatter (built from the object's
  * structured fields) followed by the markdown content.
@@ -26,7 +26,7 @@ export function buildPrimaryContent(obj) {
     if (obj.scope !== undefined)
         meta.scope = obj.scope;
     if (obj.mode !== undefined)
-        meta.mode = obj.mode;
+        meta.inclusion = modeToInclusion(obj.mode);
     if (obj.enabled !== undefined)
         meta.enabled = obj.enabled;
     if (obj.guid !== undefined)
@@ -79,6 +79,34 @@ export function parseFrontmatter(content) {
         result.name = meta.name;
     return result;
 }
+// ── Mode normalization ───────────────────────────────────────────────────────
+/**
+ * The API only accepts the backend `mode` enum (`auto` | `referenced` | `always`),
+ * but on disk (and in the Xano UI) this is the `inclusion` field with values
+ * "on demand" / "manual" / "always" — see `modeToInclusion` for the pull-side
+ * mapping. Hand-authored frontmatter (or content copied from the UI) commonly
+ * uses the display label instead, which the API rejects with e.g. `Input
+ * "on demand" is not one of the allowable values.` (DEV-7380/DEV-7382).
+ * Normalize known aliases before every push so the backend enum value is
+ * always what's sent.
+ */
+const MODE_ALIASES = {
+    'always included': 'always',
+    'manual': 'referenced',
+    'on demand': 'auto',
+};
+function normalizeMode(mode) {
+    return MODE_ALIASES[mode.trim().toLowerCase()] ?? mode;
+}
+/** Map the backend `mode` enum to the `inclusion:` frontmatter value shown in the Xano UI. */
+const MODE_TO_INCLUSION = {
+    always: 'always',
+    auto: 'on demand',
+    referenced: 'manual',
+};
+function modeToInclusion(mode) {
+    return MODE_TO_INCLUSION[mode] ?? mode;
+}
 // ── Path mapping (CLI-owned layout) ────────────────────────────────────────────
 /**
  * Allocate a unique snake_case folder/file segment per call, suffixing
@@ -205,13 +233,14 @@ export function collectKnowledgeObjects(inputDir, include, exclude) {
             : inferType(posixPath);
         // The API requires description/scope/mode/enabled on every item, so default
         // them when a hand-authored file omits them (pulled files always carry them).
+        // `mode` is read from the on-disk `inclusion:` field (see modeToInclusion).
         const obj = {
             content: body,
             description: typeof meta.description === 'string' ? meta.description : '',
             enabled: typeof meta.enabled === 'boolean' ? meta.enabled : true,
             filePath: absPath,
             knowledge_type: knowledgeType,
-            mode: typeof meta.mode === 'string' ? meta.mode : 'auto',
+            mode: typeof meta.inclusion === 'string' ? normalizeMode(meta.inclusion) : 'auto',
             name: typeof meta.name === 'string' ? meta.name : deriveName(posixPath),
             scope: typeof meta.scope === 'string' ? meta.scope : 'workspace',
         };

package/dist/utils/multidoc-push.d.ts

@@ -25,14 +25,19 @@ export interface PushTarget {
     instanceOrigin: string;
     /** Human-readable label for log messages (e.g., "sandbox environment", "workspace 40") */
     label: string;
+    /**
+     * The id of the source workspace being pushed (from the active profile). Sent to the sandbox
+     * so the backend can flag a mismatch when it differs from the workspace the sandbox last held.
+     */
+    sourceWorkspaceId?: string;
     /** Does this target support branches? */
     supportsBranches: boolean;
     /** Does this target support the partial query param? */
     supportsPartial: boolean;
     /**
-     * Warn when the workspace embedded in the local push differs from the workspace currently
-     * loaded on the target (per dry-run). Used by sandbox push because the sandbox is shared
-     * across workspaces and pushing onto a different workspace can leave stale state behind.
+     * Warn when the sandbox currently holds a different source workspace than the one being pushed
+     * (per the dry-run's `source_workspace_mismatch` flag). Used by sandbox push because the sandbox
+     * is shared across workspaces and pushing onto a different one can leave stale state behind.
      */
     warnOnWorkspaceMismatch?: boolean;
 }
@@ -51,17 +56,6 @@ export interface PushContext {
     knowledge?: KnowledgeConfig;
     verboseFetch: (url: string, options: RequestInit, verbose: boolean, authToken?: string) => Promise<Response>;
 }
-export declare const WORKSPACE_MISMATCH_THRESHOLD = 10;
-/**
- * Sum all impactful operations in a dry-run summary. `deleted` is only counted when the
- * caller actually intends to apply deletions (sync mode), matching what the user will see.
- */
-export declare function countSummaryChanges(summary: Record<string, {
-    created: number;
-    deleted: number;
-    truncated: number;
-    updated: number;
-}>, shouldDelete: boolean): number;
 /**
  * Filter document entries down to the ones the dry-run preview reports as changed,
  * used to send only the changed documents during a partial (non-`--sync`) push.
@@ -105,10 +99,6 @@ export declare function readDocuments(files: string[]): Array<{
 }>;
 export declare function renderBadReferences(badRefs: BadReference[], log: (msg: string) => void): void;
 export declare function renderBadIndexes(badIndexes: BadIndex[], log: (msg: string) => void): void;
-export declare function findLocalWorkspaceName(entries: Array<{
-    content: string;
-    filePath: string;
-}>): null | string;
 export declare function confirm(message: string): Promise<boolean>;
 /**
  * Execute a multidoc push with preview, validation, partial mode, and GUID sync.

package/dist/utils/multidoc-push.js

@@ -5,16 +5,6 @@ import { join, relative } from 'node:path';
 import { buildDocumentKey, findFilesWithGuid, parseDocument } from './document-parser.js';
 import { collectKnowledgeObjects, fetchKnowledge, knowledgePreview, pushKnowledge, syncGuidToFrontmatter, toPushItems, } from './knowledge-sync.js';
 import { checkReferences, checkTableIndexes } from './reference-checker.js';
-// Minimum total operations before a workspace mismatch is treated as worth interrupting for.
-// Small change sets (e.g., editing a single function) aren't worth a reset prompt.
-export const WORKSPACE_MISMATCH_THRESHOLD = 10;
-/**
- * Sum all impactful operations in a dry-run summary. `deleted` is only counted when the
- * caller actually intends to apply deletions (sync mode), matching what the user will see.
- */
-export function countSummaryChanges(summary, shouldDelete) {
-    return Object.values(summary).reduce((sum, c) => sum + c.created + c.updated + (shouldDelete ? c.deleted : 0) + c.truncated, 0);
-}
 /**
  * Filter document entries down to the ones the dry-run preview reports as changed,
  * used to send only the changed documents during a partial (non-`--sync`) push.
@@ -263,14 +253,6 @@ function renderPreview(result, willDelete, target, verbose, partial, log) {
     }
     log('');
 }
-export function findLocalWorkspaceName(entries) {
-    for (const entry of entries) {
-        const parsed = parseDocument(entry.content);
-        if (parsed?.type === 'workspace')
-            return parsed.name;
-    }
-    return null;
-}
 // ── Confirmation ────────────────────────────────────────────────────────────
 export async function confirm(message) {
     const readline = await import('node:readline');
@@ -435,6 +417,9 @@ export async function executePush(ctx, target, flags) {
     if (target.supportsPartial) {
         queryParams.set('partial', isPartial.toString());
     }
+    if (target.sourceWorkspaceId) {
+        queryParams.set('source_workspace_id', target.sourceWorkspaceId);
+    }
     // ── Request headers ───────────────────────────────────────────────────
     const requestHeaders = {
         accept: 'application/json',
@@ -530,32 +515,28 @@ export async function executePush(ctx, target, flags) {
                     if (flags['dry-run']) {
                         return;
                     }
-                    // Warn when the sandbox currently holds a different workspace than the one being
-                    // pushed and the change set is large enough that stale state is a real risk.
+                    // Warn when the sandbox currently holds a different source workspace than the one being
+                    // pushed. The backend compares the source workspace id we sent against the id stored on
+                    // the sandbox from its last push, so this is reliable regardless of whether the push
+                    // includes a workspace-settings document (unlike the old name comparison).
                     let mismatchConfirmed = false;
-                    if (target.warnOnWorkspaceMismatch && preview.workspace_name) {
-                        const localWorkspaceName = findLocalWorkspaceName(documentEntries);
-                        const totalChanges = countSummaryChanges(preview.summary, shouldDelete);
-                        if (localWorkspaceName &&
-                            localWorkspaceName !== preview.workspace_name &&
-                            totalChanges >= WORKSPACE_MISMATCH_THRESHOLD) {
-                            log('');
-                            log(ux.colorize('yellow', ux.colorize('bold', '=== Workspace Mismatch ===')));
-                            log('');
-                            log(ux.colorize('yellow', `Sandbox currently holds workspace "${preview.workspace_name}", but you're pushing "${localWorkspaceName}" with ${totalChanges} changes.`));
-                            log(ux.colorize('yellow', 'Pushing on top of a different workspace can leave stale data behind. Run `xano sandbox reset` first to start clean.'));
-                            log('');
-                            if (process.stdin.isTTY) {
-                                const proceed = await confirm('Continue with push anyway?');
-                                if (!proceed) {
-                                    log('Push cancelled. Run `xano sandbox reset` then retry.');
-                                    return;
-                                }
-                                mismatchConfirmed = true;
-                            }
-                            else {
-                                command.error('Workspace mismatch detected in non-interactive mode. Run `xano sandbox reset` first to start clean.');
+                    if (target.warnOnWorkspaceMismatch && preview.source_workspace_mismatch) {
+                        log('');
+                        log(ux.colorize('yellow', ux.colorize('bold', '=== Workspace Mismatch ===')));
+                        log('');
+                        log(ux.colorize('yellow', "This sandbox currently holds a different workspace than the one you're pushing."));
+                        log(ux.colorize('yellow', 'Pushing on top of it can leave stale data behind. Run `xano sandbox reset` first to start clean.'));
+                        log('');
+                        if (process.stdin.isTTY) {
+                            const proceed = await confirm('Continue with push anyway?');
+                            if (!proceed) {
+                                log('Push cancelled. Run `xano sandbox reset` then retry.');
+                                return;
                             }
+                            mismatchConfirmed = true;
+                        }
+                        else {
+                            command.error('Workspace mismatch detected in non-interactive mode. Run `xano sandbox reset` first to start clean.');
                         }
                     }
                     // Confirm with user (skip if workspace mismatch prompt already obtained confirmation)