@xano/cli 1.0.2 → 1.0.3-beta.5

package/dist/commands/static_host/deploy/index.js

@@ -0,0 +1,105 @@
+import { Args, Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostDeploy extends BaseCommand {
+    static args = {
+        static_host: Args.string({
+            description: 'Static Host name',
+            required: true,
+        }),
+    };
+    static description = 'Deploy a static host build to an environment';
+    static examples = [
+        `$ xano static_host deploy default --build_id 52 --env dev
+Deployed build 52 to dev
+URL: https://x1234-abcd.static.xano.io
+`,
+        `$ xano static_host deploy default --build_id 52 --env prod
+Deployed build 52 to prod
+URL: https://x1234-abcd.static.xano.io
+`,
+        `$ xano static_host deploy myhost --build_id 123 --env dev -w 40
+Deployed build 123 to dev
+`,
+        `$ xano static_host deploy default --build_id 52 --env prod -o json`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        build_id: Flags.string({
+            description: 'Build ID to deploy',
+            required: true,
+        }),
+        env: Flags.string({
+            description: 'Target environment',
+            options: ['dev', 'prod'],
+            required: true,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', '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(StaticHostDeploy);
+        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 static_host deploy <static_host> --build_id <id> --env <env> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${args.static_host}/build/${flags.build_id}/env`;
+        try {
+            const response = await this.verboseFetch(apiUrl, {
+                body: JSON.stringify({ env: flags.env }),
+                headers: {
+                    'accept': 'application/json',
+                    'Authorization': `Bearer ${profile.access_token}`,
+                    'Content-Type': 'application/json',
+                },
+                method: 'POST',
+            }, 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 result = await response.json();
+            if (!result || typeof result !== 'object') {
+                this.error('Unexpected API response format');
+            }
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(result, null, 2));
+            }
+            else {
+                this.log(`Deployed build ${flags.build_id} to ${flags.env}`);
+                if (result.default_url) {
+                    this.log(`URL: ${result.default_url}`);
+                }
+                if (result.custom_url) {
+                    this.log(`Custom URL: ${result.custom_url}`);
+                }
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to deploy build: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to deploy build: ${String(error)}`);
+            }
+        }
+    }
+}

package/dist/commands/static_host/edit/index.d.ts

@@ -0,0 +1,23 @@
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostEdit extends BaseCommand {
+    static args: {
+        static_host: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        description: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'git-private-key-file': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'git-public-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'git-repo': 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>;
+        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>;
+    /** Fetch the current host record so unspecified fields are preserved on edit. */
+    private fetchHost;
+}

package/dist/commands/static_host/edit/index.js

@@ -0,0 +1,151 @@
+import { Args, Flags } from '@oclif/core';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostEdit extends BaseCommand {
+    static args = {
+        static_host: Args.string({
+            description: 'Static Host name to edit',
+            required: true,
+        }),
+    };
+    static description = 'Update a static host\'s name, description, or git configuration';
+    static examples = [
+        `$ xano static_host edit newsite --description "Marketing site"
+Updated static host 'newsite'
+`,
+        `$ xano static_host edit newsite --name newsite-v2
+Updated static host 'newsite' (renamed to 'newsite-v2')
+`,
+        `$ xano static_host edit newsite --git-repo git@github.com:me/site.git --git-private-key-file ./deploy_key
+Updated static host 'newsite'
+`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        description: Flags.string({
+            description: 'New description for the static host',
+            required: false,
+        }),
+        'git-private-key-file': Flags.string({
+            description: 'Path to a file containing the git SSH private key (read from disk; never passed on the command line)',
+            required: false,
+        }),
+        'git-public-key': Flags.string({
+            description: 'Git SSH public key',
+            required: false,
+        }),
+        'git-repo': Flags.string({
+            description: 'Git repository URL (e.g. git@github.com:org/repo.git)',
+            required: false,
+        }),
+        name: Flags.string({
+            description: 'New name for the static host (renaming changes the deployed hostname)',
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', '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(StaticHostEdit);
+        const hasGitFlag = Boolean(flags['git-repo'] || flags['git-private-key-file'] || flags['git-public-key']);
+        if (!flags.name && flags.description === undefined && !hasGitFlag) {
+            this.error('Nothing to update. Provide at least one of --name, --description, or a --git-* flag.');
+        }
+        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 static_host edit <static_host> --name <name> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        // The edit endpoint requires `name`, and merges git as a whole object —
+        // so fetch the current record first and only override the fields the user set.
+        const current = await this.fetchHost(profile, workspaceId, args.static_host, flags.verbose);
+        const git = { ...current.git };
+        if (flags['git-repo'] !== undefined)
+            git.repo = flags['git-repo'];
+        if (flags['git-public-key'] !== undefined)
+            git.public_key = flags['git-public-key'];
+        if (flags['git-private-key-file'] !== undefined) {
+            const keyPath = path.resolve(flags['git-private-key-file']);
+            if (!fs.existsSync(keyPath)) {
+                this.error(`Private key file not found: ${keyPath}`);
+            }
+            git.private_key = fs.readFileSync(keyPath, 'utf8').trim();
+        }
+        const body = {
+            description: flags.description ?? current.description ?? '',
+            git: {
+                private_key: git.private_key ?? '',
+                public_key: git.public_key ?? '',
+                repo: git.repo ?? '',
+            },
+            name: flags.name ?? current.name,
+        };
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${args.static_host}/edit`;
+        try {
+            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 update static host '${args.static_host}'`);
+                this.error(message);
+            }
+            const updated = (await response.json());
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(updated, null, 2));
+            }
+            else {
+                const renamed = flags.name && flags.name !== args.static_host ? ` (renamed to '${flags.name}')` : '';
+                this.log(`Updated static host '${args.static_host}'${renamed}`);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to update static host: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to update static host: ${String(error)}`);
+            }
+        }
+    }
+    /** Fetch the current host record so unspecified fields are preserved on edit. */
+    async fetchHost(profile, workspaceId, staticHost, verbose) {
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}`;
+        const response = await this.verboseFetch(apiUrl, {
+            headers: {
+                accept: 'application/json',
+                Authorization: `Bearer ${profile.access_token}`,
+            },
+            method: 'GET',
+        }, verbose, profile.access_token);
+        if (!response.ok) {
+            const message = await this.parseApiError(response, `Static host '${staticHost}' not found`);
+            this.error(message);
+        }
+        return (await response.json());
+    }
+}

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

@@ -0,0 +1,18 @@
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostGet extends BaseCommand {
+    static args: {
+        static_host: import("@oclif/core/interfaces").Arg<string, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        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>;
+    /** Print a one-line summary for a dev/prod env if it has been deployed. */
+    private logEnv;
+}

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

@@ -0,0 +1,94 @@
+import { Args, Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostGet extends BaseCommand {
+    static args = {
+        static_host: Args.string({
+            description: 'Static Host name',
+            required: true,
+        }),
+    };
+    static description = 'Get a single static host\'s details (name, git config, dev/prod environments)';
+    static examples = [
+        `$ xano static_host get newsite
+Static Host: newsite
+ID: 5
+Dev: https://newsite-dev-....dev.xano.io (v2)
+`,
+        `$ xano static_host get newsite -w 40 -o json`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', '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(StaticHostGet);
+        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 static_host get <static_host> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${args.static_host}`;
+        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 message = await this.parseApiError(response, `Failed to get static host '${args.static_host}'`);
+                this.error(message);
+            }
+            const host = (await response.json());
+            if (flags.output === 'json') {
+                this.log(JSON.stringify(host, null, 2));
+            }
+            else {
+                this.log(`Static Host: ${host.name}`);
+                this.log(`ID: ${host.id}`);
+                if (host.description)
+                    this.log(`Description: ${host.description}`);
+                if (host.git?.repo)
+                    this.log(`Git: ${host.git.repo}`);
+                this.logEnv('Dev', host.dev);
+                this.logEnv('Prod', host.prod);
+            }
+        }
+        catch (error) {
+            if (error instanceof Error) {
+                this.error(`Failed to get static host: ${error.message}`);
+            }
+            else {
+                this.error(`Failed to get static host: ${String(error)}`);
+            }
+        }
+    }
+    /** Print a one-line summary for a dev/prod env if it has been deployed. */
+    logEnv(label, env) {
+        if (!env?.default_url)
+            return;
+        const modeInfo = env.mode ? ` (${env.mode})` : '';
+        const custom = env.custom_url ? ` [custom: ${env.custom_url}]` : '';
+        this.log(`${label}: ${env.default_url}${modeInfo}${custom}`);
+    }
+}

package/dist/commands/static_host/migrate/index.d.ts

@@ -0,0 +1,44 @@
+import BaseCommand from '../../../base-command.js';
+export interface StaticHostEnv {
+    canonical?: null | string;
+    mode?: null | string;
+}
+export interface StaticHost {
+    dev?: StaticHostEnv;
+    id: number;
+    name: string;
+    prod?: StaticHostEnv;
+}
+export default class StaticHostMigrate extends BaseCommand {
+    static args: {
+        static_host: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
+    };
+    static description: string;
+    static examples: string[];
+    static flags: {
+        all: import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        'dry-run': import("@oclif/core/interfaces").BooleanFlag<boolean>;
+        env: 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>;
+    /** List all static hosts in the workspace (paginates until exhausted). */
+    private listHosts;
+    /** Discover v1 hosts and migrate each, with a per-host report. */
+    private migrateAll;
+    /** POST the meta migrate endpoint for one host. Throws on a non-OK response. */
+    private migrateHost;
+    /** Migrate a single named host and report the result. */
+    private migrateOne;
+}
+/** An env still needs migration when it's been deployed (has a canonical) but isn't yet v2. */
+export declare function envNeedsMigration(e?: StaticHostEnv): boolean;
+/**
+ * A host still needs migration when an env of interest is v1. When --env is given,
+ * only that env is considered; otherwise either env being v1 qualifies the host.
+ */
+export declare function isV1(host: StaticHost, env?: string): boolean;

package/dist/commands/static_host/migrate/index.js

@@ -0,0 +1,205 @@
+import { Args, Flags } from '@oclif/core';
+import BaseCommand from '../../../base-command.js';
+export default class StaticHostMigrate extends BaseCommand {
+    static args = {
+        static_host: Args.string({
+            description: 'Static Host name to migrate (omit when using --all)',
+            required: false,
+        }),
+    };
+    static description = 'Migrate a static host to instance-managed (v2) hosting. Reparents the Ingress, verifies it, clears master, and marks the host v2.';
+    static examples = [
+        `$ xano static_host migrate newsite
+Migrated 'newsite' to v2
+`,
+        `$ xano static_host migrate newsite --env dev
+Migrated 'newsite' (dev) to v2
+`,
+        `$ xano static_host migrate --all
+Migrating 3 v1 host(s)...
+  ✓ newsite
+  ✓ marketing
+  ✗ legacy — <error>
+`,
+        `$ xano static_host migrate --all --dry-run
+Would migrate 3 v1 host(s): newsite, marketing, legacy
+`,
+    ];
+    static flags = {
+        ...BaseCommand.baseFlags,
+        all: Flags.boolean({
+            default: false,
+            description: 'Migrate every host still on v1 in the workspace',
+            required: false,
+        }),
+        'dry-run': Flags.boolean({
+            default: false,
+            description: 'List the hosts that would be migrated without changing anything',
+            required: false,
+        }),
+        env: Flags.string({
+            description: 'Which environment to migrate (migrates both if omitted)',
+            options: ['dev', 'prod'],
+            required: false,
+        }),
+        output: Flags.string({
+            char: 'o',
+            default: 'summary',
+            description: 'Output format',
+            options: ['summary', '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(StaticHostMigrate);
+        if (!flags.all && !args.static_host) {
+            this.error('Provide a static host name, or use --all to migrate every v1 host.');
+        }
+        if (flags.all && args.static_host) {
+            this.error('Use either a static host name or --all, not both.');
+        }
+        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 static_host migrate <static_host> -w <workspace_id>\n` +
+                `  2. Set it in your profile using: xano profile edit ${profileName} -w <workspace_id>`);
+        }
+        if (flags.all) {
+            await this.migrateAll(profile, workspaceId, flags);
+            return;
+        }
+        await this.migrateOne(profile, workspaceId, args.static_host, flags);
+    }
+    /** List all static hosts in the workspace (paginates until exhausted). */
+    async listHosts(profile, workspaceId, verbose) {
+        const hosts = [];
+        const perPage = 100;
+        for (let page = 1;; page++) {
+            const listUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host?page=${page}&per_page=${perPage}`;
+            // eslint-disable-next-line no-await-in-loop
+            const response = await this.verboseFetch(listUrl, {
+                headers: {
+                    accept: 'application/json',
+                    Authorization: `Bearer ${profile.access_token}`,
+                },
+                method: 'GET',
+            }, verbose, profile.access_token);
+            if (!response.ok) {
+                const errorText = await response.text(); // eslint-disable-line no-await-in-loop
+                this.error(`Failed to list static hosts: ${response.status} ${response.statusText}\n${errorText}`);
+            }
+            const data = (await response.json()); // eslint-disable-line no-await-in-loop
+            const pageHosts = Array.isArray(data)
+                ? data
+                : data && typeof data === 'object' && 'items' in data && Array.isArray(data.items)
+                    ? data.items
+                    : [];
+            hosts.push(...pageHosts);
+            if (pageHosts.length < perPage)
+                break;
+        }
+        return hosts;
+    }
+    /** Discover v1 hosts and migrate each, with a per-host report. */
+    async migrateAll(profile, workspaceId, flags) {
+        const hosts = await this.listHosts(profile, workspaceId, flags.verbose);
+        const v1Hosts = hosts.filter((h) => isV1(h, flags.env));
+        if (v1Hosts.length === 0) {
+            this.log('No v1 hosts to migrate — all hosts are already instance-managed (v2).');
+            return;
+        }
+        if (flags['dry-run']) {
+            const names = v1Hosts.map((h) => h.name);
+            if (flags.output === 'json') {
+                this.log(JSON.stringify({ dryRun: true, wouldMigrate: names }, null, 2));
+            }
+            else {
+                this.log(`Would migrate ${names.length} v1 host(s): ${names.join(', ')}`);
+            }
+            return;
+        }
+        if (flags.output !== 'json') {
+            this.log(`Migrating ${v1Hosts.length} v1 host(s)...`);
+        }
+        const results = [];
+        for (const host of v1Hosts) {
+            try {
+                // eslint-disable-next-line no-await-in-loop
+                await this.migrateHost(profile, workspaceId, host.name, flags.env, flags.verbose);
+                results.push({ migrated: true, static_host: host.name });
+                if (flags.output !== 'json')
+                    this.log(`  ✓ ${host.name}`);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                results.push({ error: message, migrated: false, static_host: host.name });
+                if (flags.output !== 'json')
+                    this.log(`  ✗ ${host.name} — ${message}`);
+            }
+        }
+        if (flags.output === 'json') {
+            this.log(JSON.stringify({ results }, null, 2));
+        }
+        else {
+            const ok = results.filter((r) => r.migrated).length;
+            const failed = results.length - ok;
+            this.log(`Done: ${ok} migrated${failed > 0 ? `, ${failed} failed` : ''}.`);
+        }
+    }
+    /** POST the meta migrate endpoint for one host. Throws on a non-OK response. */
+    async migrateHost(profile, workspaceId, staticHost, env, verbose) {
+        const apiUrl = `${profile.instance_origin}/api:meta/workspace/${workspaceId}/static_host/${staticHost}/migrate`;
+        const response = await this.verboseFetch(apiUrl, {
+            body: JSON.stringify(env ? { env } : {}),
+            headers: {
+                accept: 'application/json',
+                Authorization: `Bearer ${profile.access_token}`,
+                'Content-Type': 'application/json',
+            },
+            method: 'POST',
+        }, verbose, profile.access_token);
+        if (!response.ok) {
+            const message = await this.parseApiError(response, `Migrate failed for '${staticHost}'`);
+            throw new Error(message);
+        }
+        return (await response.json());
+    }
+    /** Migrate a single named host and report the result. */
+    async migrateOne(profile, workspaceId, staticHost, flags) {
+        const result = await this.migrateHost(profile, workspaceId, staticHost, flags.env, flags.verbose);
+        const envSuffix = flags.env ? ` (${flags.env})` : '';
+        if (flags.output === 'json') {
+            this.log(JSON.stringify({ env: flags.env ?? null, migrated: true, static_host: staticHost, ...result }, null, 2));
+        }
+        else {
+            this.log(`Migrated '${staticHost}'${envSuffix} to v2`);
+        }
+    }
+}
+/** An env still needs migration when it's been deployed (has a canonical) but isn't yet v2. */
+export function envNeedsMigration(e) {
+    return Boolean(e?.canonical) && e?.mode !== 'v2';
+}
+/**
+ * A host still needs migration when an env of interest is v1. When --env is given,
+ * only that env is considered; otherwise either env being v1 qualifies the host.
+ */
+export function isV1(host, env) {
+    if (env === 'dev')
+        return envNeedsMigration(host.dev);
+    if (env === 'prod')
+        return envNeedsMigration(host.prod);
+    return envNeedsMigration(host.dev) || envNeedsMigration(host.prod);
+}

package/dist/utils/multidoc-push.js

@@ -589,7 +589,7 @@ export async function executePush(ctx, target, flags) {
             }
             catch {
                 if (flags.verbose) {
-                    log('Server response is not JSON; skipping GUID sync');
+                    log(`Server response is not JSON; skipping GUID sync\n${responseText}`);
                 }
             }
         }

package/dist/utils/reference-checker.js

@@ -170,8 +170,8 @@ export function checkTableIndexes(documents) {
     return badIndexes;
 }
 function extractSchemaFields(content) {
-    // id and created_at are auto-added during import
-    const fields = new Set(['id', 'created_at']);
+    // id, created_at, and xdo are system fields not declared in the schema
+    const fields = new Set(['id', 'created_at', 'xdo']);
     // Find the schema block by matching braces
     const schemaStart = content.match(/\bschema\s*\{/);
     if (!schemaStart || schemaStart.index === undefined)