@nocobase/cli 2.1.0-alpha.2 → 2.1.0-alpha.21

package/dist/commands/init.js

@@ -0,0 +1,779 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+import { Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { getEnv, upsertEnv } from "../lib/auth-store.js";
+import { runPromptCatalog, } from "../lib/prompt-catalog.js";
+import { runPromptCatalogWebUI, } from "../lib/prompt-web-ui.js";
+import { validateApiBaseUrl, validateEnvKey } from "../lib/prompt-validators.js";
+import { run } from "../lib/run-npm.js";
+import Download from "./download.js";
+import EnvAdd from "./env/add.js";
+import Install, { defaultDbPortForDialect } from "./install.js";
+import _ from 'lodash';
+const DEFAULT_INIT_API_BASE_URL = 'http://localhost:13000/api';
+const DEFAULT_INIT_APP_NAME = 'local';
+const DOWNLOAD_OUTPUT_DIR_PROMPT = Download.prompts.outputDir;
+const CONFIG_SCOPE = 'project';
+function withExtraHidden(def, extraHidden) {
+    if (def.type === 'run') {
+        return def;
+    }
+    return {
+        ...def,
+        hidden: (values) => extraHidden(values) || (def.hidden?.(values) ?? false),
+    };
+}
+function existingAppOnly(def) {
+    return withExtraHidden(def, (values) => values.hasNocobase !== 'yes');
+}
+function newInstallOnly(def) {
+    return withExtraHidden(def, (values) => values.hasNocobase !== 'no');
+}
+function downloadInNewInstallOnly(def) {
+    return withExtraHidden(def, (values) => values.hasNocobase !== 'no' || values.fetchSource !== true);
+}
+function argvHasToken(argv, tokens) {
+    return tokens.some((token) => argv.includes(token));
+}
+function shouldAllowExistingInitEnv() {
+    return argvHasToken(process.argv.slice(2), ['--force', '-f']);
+}
+async function validateInitAppName(value) {
+    const formatError = validateEnvKey(value);
+    if (formatError) {
+        return formatError;
+    }
+    const envName = String(value ?? '').trim();
+    if (!envName) {
+        return undefined;
+    }
+    const existingEnv = await getEnv(envName, { scope: 'project' });
+    if (existingEnv) {
+        if (shouldAllowExistingInitEnv()) {
+            return undefined;
+        }
+        return `Env "${envName}" already exists in this workspace. Choose another app name.`;
+    }
+    return undefined;
+}
+function highlightInitValidationMessage(message) {
+    return message.replace(/Env "([^"]+)"/, (_match, envName) => `Env ${pc.cyan(pc.bold(`"${envName}"`))}`);
+}
+function formatInitValidationMessage(message) {
+    if (/"appName" is required/.test(message)) {
+        return [
+            'App name is required when prompts are skipped.',
+            'The app name is also the CLI env name. Use `nb init --yes --env <envName>` to continue.',
+        ].join('\n');
+    }
+    return message;
+}
+function formatResumeEnvRequiredMessage() {
+    return [
+        'Env name is required when resuming setup.',
+        'App name is also the CLI env name. Use `nb init --resume --env <envName>` to continue.',
+    ].join('\n');
+}
+export default class Init extends Command {
+    static summary = 'Set up NocoBase so coding agents can connect and work with it';
+    static description = `Set up NocoBase for coding agents in the current workspace.
+
+\`nb init\` prepares a NocoBase environment that coding agents can use. It supports two setup paths:
+
+- Connect an existing NocoBase app and save it as a CLI env.
+- Install a new NocoBase app, then save it as a CLI env.
+
+It can also install NocoBase AI coding skills (\`nocobase/skills\`) so agents get the project-specific workflow guidance.
+
+If setup was interrupted earlier, use \`--resume\` with an existing env name to continue from the saved workspace config.
+
+Prompt modes:
+- Default: guided prompts in the terminal.
+- \`--ui\`: open the same setup flow in a local browser form.
+- \`-y\`, \`--yes\`: skip prompts. In this mode \`--env <envName>\` is required, and init creates a new local NocoBase app with safe defaults.
+
+\`--ui\` cannot be combined with \`--yes\`.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --env app1',
+        '<%= config.bin %> <%= command.id %> --env app1 --ui',
+        '<%= config.bin %> <%= command.id %> --ui',
+        '<%= config.bin %> <%= command.id %> --env app1 --yes',
+        '<%= config.bin %> <%= command.id %> --env app1 --resume',
+        '<%= config.bin %> <%= command.id %> --env app1 --yes --source docker --version alpha',
+        '<%= config.bin %> <%= command.id %> --env app1 --yes --source npm --version alpha --app-port 13080',
+        '<%= config.bin %> <%= command.id %> --env app1 --yes --source git --version fix/cli-v2',
+        '<%= config.bin %> <%= command.id %> --ui --ui-port 3000',
+    ];
+    static prompts = {
+        appName: {
+            type: 'text',
+            message: 'App name (also used as the CLI env name)',
+            placeholder: DEFAULT_INIT_APP_NAME,
+            required: true,
+            validate: validateInitAppName,
+        },
+        hasNocobase: {
+            type: 'select',
+            variant: 'radio',
+            message: 'Do you already have a NocoBase application?',
+            options: [
+                {
+                    value: 'no',
+                    label: "I don't have a NocoBase application yet",
+                },
+                {
+                    value: 'yes',
+                    label: 'I already have a NocoBase application',
+                },
+            ],
+            initialValue: 'no',
+            yesInitialValue: 'no',
+            required: true,
+        },
+        installSkills: {
+            type: 'boolean',
+            message: 'Install NocoBase AI coding skills (nocobase/skills)?',
+            initialValue: true,
+            yesInitialValue: true,
+        },
+        apiBaseUrl: existingAppOnly({
+            type: 'text',
+            message: 'API base URL',
+            placeholder: DEFAULT_INIT_API_BASE_URL,
+            required: true,
+            validate: validateApiBaseUrl,
+        }),
+        authType: existingAppOnly(EnvAdd.prompts.authType),
+        accessToken: existingAppOnly(EnvAdd.prompts.accessToken),
+        lang: newInstallOnly(Install.appPrompts.lang),
+        appRootPath: newInstallOnly(Install.appPrompts.appRootPath),
+        appPort: newInstallOnly(Install.appPrompts.appPort),
+        storagePath: newInstallOnly(Install.appPrompts.storagePath),
+        fetchSource: newInstallOnly(Install.appPrompts.fetchSource),
+        source: downloadInNewInstallOnly(Download.prompts.source),
+        version: downloadInNewInstallOnly(Download.prompts.version),
+        dockerRegistry: downloadInNewInstallOnly(Download.prompts.dockerRegistry),
+        dockerPlatform: downloadInNewInstallOnly(Download.prompts.dockerPlatform),
+        dockerSave: downloadInNewInstallOnly(Download.prompts.dockerSave),
+        gitUrl: downloadInNewInstallOnly(Download.prompts.gitUrl),
+        outputDir: downloadInNewInstallOnly({
+            ...DOWNLOAD_OUTPUT_DIR_PROMPT,
+            hidden: (values) => {
+                const source = String(values.source ?? '').trim();
+                if (source === 'npm' || source === 'git') {
+                    return true;
+                }
+                return DOWNLOAD_OUTPUT_DIR_PROMPT.hidden?.(values) ?? false;
+            },
+            initialValue: (values) => {
+                const source = String(values.source ?? '').trim();
+                if (source === 'npm' || source === 'git') {
+                    const appRootPath = String(values.appRootPath ?? '').trim();
+                    if (appRootPath) {
+                        return appRootPath;
+                    }
+                }
+                const initialValue = DOWNLOAD_OUTPUT_DIR_PROMPT.initialValue;
+                return typeof initialValue === 'function' ? initialValue(values) : String(initialValue ?? '');
+            },
+        }),
+        npmRegistry: downloadInNewInstallOnly(Download.prompts.npmRegistry),
+        replace: downloadInNewInstallOnly(Download.prompts.replace),
+        devDependencies: downloadInNewInstallOnly(Download.prompts.devDependencies),
+        build: downloadInNewInstallOnly(Download.prompts.build),
+        buildDts: downloadInNewInstallOnly(Download.prompts.buildDts),
+        builtinDb: newInstallOnly(Install.dbPrompts.builtinDb),
+        dbDialect: newInstallOnly(Install.dbPrompts.dbDialect),
+        dbHost: newInstallOnly(Install.dbPrompts.dbHost),
+        dbPort: newInstallOnly(Install.dbPrompts.dbPort),
+        dbDatabase: newInstallOnly(Install.dbPrompts.dbDatabase),
+        dbUser: newInstallOnly(Install.dbPrompts.dbUser),
+        dbPassword: newInstallOnly(Install.dbPrompts.dbPassword),
+        rootUsername: newInstallOnly(Install.rootUserPrompts.rootUsername),
+        rootEmail: newInstallOnly(Install.rootUserPrompts.rootEmail),
+        rootPassword: newInstallOnly(Install.rootUserPrompts.rootPassword),
+        rootNickname: newInstallOnly(Install.rootUserPrompts.rootNickname),
+    };
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip prompts and create a new local NocoBase app. Requires an app/env name.',
+            default: false,
+        }),
+        env: Flags.string({
+            char: 'e',
+            description: 'App name / CLI env name for this setup. Required with --yes and --resume',
+        }),
+        'install-skills': Flags.boolean({
+            description: 'Install NocoBase AI coding skills (`nocobase/skills`) for this workspace',
+            default: false,
+        }),
+        ui: Flags.boolean({
+            description: 'Open the guided setup flow in a local browser form (not valid with --yes)',
+            default: false,
+        }),
+        'ui-host': Flags.string({
+            description: 'Host for the local --ui setup server (default: 127.0.0.1)',
+        }),
+        'ui-port': Flags.integer({
+            description: 'Port for the local --ui setup server; 0 lets the OS choose an available port',
+            min: 0,
+            max: 65535,
+        }),
+        ..._.omit(Install.flags, ['yes', 'env']),
+    };
+    async run() {
+        const parsedResult = await this.parse(Init);
+        const flags = parsedResult.flags;
+        const normalizedFlags = { ...flags };
+        if (normalizedFlags.ui && normalizedFlags.yes) {
+            this.error('--ui cannot be used with --yes.');
+        }
+        if (normalizedFlags.ui && normalizedFlags.resume) {
+            this.error('--ui cannot be used with --resume.');
+        }
+        if (!normalizedFlags.ui &&
+            (normalizedFlags['ui-host'] !== undefined || normalizedFlags['ui-port'] !== undefined)) {
+            this.error('--ui-host and --ui-port require --ui.');
+        }
+        if (normalizedFlags.resume) {
+            const envName = String(normalizedFlags.env ?? '').trim();
+            if (!envName) {
+                p.log.error(formatResumeEnvRequiredMessage());
+                this.exit(1);
+            }
+            p.intro('Set Up NocoBase for Coding Agents');
+            if (Boolean(normalizedFlags['install-skills'])) {
+                try {
+                    p.log.step('Installing NocoBase agent skills (npx -y skills add nocobase/skills)');
+                    await run('npx', ['-y', 'skills', 'add', 'nocobase/skills', '-y']);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    p.outro(pc.red(`Skills install failed: ${message}`));
+                    this.error(message);
+                }
+            }
+            try {
+                p.log.step(`Resuming setup for env "${envName}" from the saved workspace config`);
+                await this.config.runCommand('install', this.buildResumeInstallArgv(normalizedFlags));
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                p.outro(pc.red(message));
+                this.error(message);
+            }
+            p.outro('Workspace init finished.');
+            return;
+        }
+        const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY);
+        const useBrowserUi = Boolean(normalizedFlags.ui);
+        let presetValues = this.buildPresetValuesFromFlags(normalizedFlags);
+        if (normalizedFlags.yes && !String(presetValues.appName ?? '').trim()) {
+            const formatted = formatInitValidationMessage('Non-interactive: "appName" is required; set initialValues.appName, yesInitialValues.appName, yesInitialValue on the block, or initialValue.');
+            p.log.error(highlightInitValidationMessage(formatted));
+            this.exit(1);
+        }
+        const appName = String(presetValues.appName ?? '').trim();
+        if (useBrowserUi) {
+            p.intro('Set Up NocoBase for Coding Agents');
+            p.log.info('A local setup form will open in your browser. Submit the form there to continue in this terminal.');
+        }
+        else {
+            p.intro('Set Up NocoBase for Coding Agents');
+            if (normalizedFlags.yes) {
+                p.log.info(`Prompts skipped (--yes). NocoBase will be installed for env "${appName}" using the provided flags and safe defaults.`);
+            }
+            else if (!interactive) {
+                p.log.warn('No interactive terminal detected. NocoBase will be installed using the provided flags and safe defaults.');
+            }
+        }
+        const dynamicInitialValues = await Init.buildDynamicInitialValuesForInstall(normalizedFlags, presetValues);
+        if (useBrowserUi) {
+            presetValues = await runPromptCatalogWebUI({
+                stages: Init.buildWebUiStages(),
+                values: {
+                    ...dynamicInitialValues,
+                    ...presetValues,
+                },
+                host: normalizedFlags['ui-host']?.trim() || '127.0.0.1',
+                port: normalizedFlags['ui-port'] ?? 0,
+                pageTitle: 'Set Up NocoBase for Coding Agents',
+                documentHeading: 'Set Up NocoBase for Coding Agents',
+                documentHint: 'Connect an existing NocoBase app or install a new one, then save it as an agent-ready CLI environment.',
+                onServerStart: ({ host, port, url }) => {
+                    this.log(`Local setup form ready at ${url} (listening on ${host}:${port}). Submit it in your browser to continue here.`);
+                },
+                onOpenBrowserError: (url, err) => {
+                    this.log(`Open this URL in your browser to continue setup: ${url} (${err instanceof Error ? err.message : String(err)})`);
+                },
+            });
+        }
+        const results = await runPromptCatalog(Init.prompts, {
+            initialValues: dynamicInitialValues,
+            values: presetValues,
+            yes: normalizedFlags.yes || useBrowserUi || !interactive,
+            hooks: {
+                onCancel: () => {
+                    p.cancel('Init cancelled.');
+                    this.exit(0);
+                },
+                onMissingNonInteractive: (message) => {
+                    const formatted = formatInitValidationMessage(message);
+                    p.log.error(highlightInitValidationMessage(formatted));
+                    this.exit(1);
+                },
+            },
+            command: this,
+        });
+        const installSkills = Boolean(results.installSkills);
+        const hasNocobase = results.hasNocobase === 'yes';
+        const existingEnv = !hasNocobase
+            ? await getEnv(String(results.appName ?? '').trim(), { scope: 'project' })
+            : undefined;
+        if (existingEnv && Boolean(normalizedFlags.force)) {
+            p.log.warn(`Reconfiguring existing env ${pc.cyan(pc.bold(`"${existingEnv.name}"`))} in this workspace because ${pc.bold('--force')} was set. The env config will be updated before install starts, then refreshed again after install succeeds.`);
+        }
+        if (installSkills) {
+            try {
+                p.log.step('Installing NocoBase agent skills (npx -y skills add nocobase/skills)');
+                await run('npx', ['-y', 'skills', 'add', 'nocobase/skills', '-y']);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                p.outro(pc.red(`Skills install failed: ${message}`));
+                this.error(message);
+            }
+        }
+        else {
+            p.log.info('Skipped NocoBase agent skills install.');
+        }
+        try {
+            // oclif explicit registry keys use `:` (e.g. `env:add`); users still type `nb env add`.
+            if (hasNocobase) {
+                p.log.step('Running nb env add');
+                await this.config.runCommand('env:add', this.buildEnvAddArgv(results));
+            }
+            else {
+                p.log.step('Saving the local env config');
+                await this.persistManagedEnvConfig(results);
+                p.log.step('Running nb install');
+                await this.config.runCommand('install', this.buildInstallArgv(results, normalizedFlags));
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            p.outro(pc.red(message));
+            this.error(message);
+        }
+        p.outro('Workspace init finished.');
+    }
+    static async buildDynamicInitialValuesForInstall(flags, presetValues) {
+        const out = {};
+        if (!Object.prototype.hasOwnProperty.call(presetValues, 'appPort')) {
+            const appInitialValues = await Install.buildAppPromptInitialValues({
+                envName: String(presetValues.appName ?? '').trim(),
+                flags: {
+                    ...flags,
+                    'app-root-path': flags['app-root-path'] ?? '',
+                    'storage-path': flags['storage-path'] ?? '',
+                },
+            });
+            if (appInitialValues.appPort !== undefined) {
+                out.appPort = appInitialValues.appPort;
+            }
+        }
+        const downloadSeed = { ...presetValues };
+        if (flags.yes
+            && !Object.prototype.hasOwnProperty.call(downloadSeed, 'source')
+            && downloadSeed.fetchSource !== false) {
+            downloadSeed.source = 'docker';
+        }
+        const dbInitial = await Install.buildDbPromptInitialValues({
+            flags,
+            downloadResults: downloadSeed,
+            dbPreset: presetValues,
+        });
+        for (const [key, value] of Object.entries(dbInitial)) {
+            if (!Object.prototype.hasOwnProperty.call(presetValues, key)) {
+                out[key] = value;
+            }
+        }
+        return out;
+    }
+    static buildWebUiStages() {
+        const c = Init.prompts;
+        return [
+            {
+                sectionTitle: 'Getting started',
+                sectionDescription: 'Pick your setup path.',
+                catalog: {
+                    appName: c.appName,
+                    hasNocobase: c.hasNocobase,
+                    installSkills: c.installSkills,
+                },
+            },
+            {
+                sectionTitle: 'Connect an existing app',
+                sectionDescription: 'Add your app connection.',
+                catalog: {
+                    apiBaseUrl: c.apiBaseUrl,
+                    authType: c.authType,
+                    accessToken: c.accessToken,
+                },
+            },
+            {
+                sectionTitle: 'Create a new app',
+                sectionDescription: 'Set project basics.',
+                catalog: {
+                    lang: c.lang,
+                    appRootPath: c.appRootPath,
+                    appPort: c.appPort,
+                    storagePath: c.storagePath,
+                    fetchSource: c.fetchSource,
+                },
+            },
+            {
+                sectionTitle: 'Download app files',
+                sectionDescription: 'Choose source and options.',
+                catalog: {
+                    source: c.source,
+                    version: c.version,
+                    dockerRegistry: c.dockerRegistry,
+                    dockerPlatform: c.dockerPlatform,
+                    dockerSave: c.dockerSave,
+                    gitUrl: c.gitUrl,
+                    outputDir: c.outputDir,
+                    npmRegistry: c.npmRegistry,
+                    replace: c.replace,
+                    devDependencies: c.devDependencies,
+                    build: c.build,
+                    buildDts: c.buildDts,
+                },
+            },
+            {
+                sectionTitle: 'Configure the database',
+                sectionDescription: 'Use built-in or custom.',
+                catalog: {
+                    builtinDb: c.builtinDb,
+                    dbDialect: c.dbDialect,
+                    dbHost: c.dbHost,
+                    dbPort: c.dbPort,
+                    dbDatabase: c.dbDatabase,
+                    dbUser: c.dbUser,
+                    dbPassword: c.dbPassword,
+                },
+            },
+            {
+                sectionTitle: 'Create an admin account',
+                sectionDescription: 'Set up the first admin.',
+                catalog: {
+                    rootUsername: c.rootUsername,
+                    rootEmail: c.rootEmail,
+                    rootPassword: c.rootPassword,
+                    rootNickname: c.rootNickname,
+                },
+            },
+        ];
+    }
+    buildPresetValuesFromFlags(flags) {
+        const preset = {};
+        const argv = process.argv.slice(2);
+        if (flags.env !== undefined && String(flags.env).trim() !== '') {
+            preset.appName = String(flags.env).trim();
+        }
+        if (flags.lang !== undefined && String(flags.lang).trim() !== '') {
+            preset.lang = String(flags.lang).trim();
+        }
+        if (flags['app-root-path'] !== undefined && String(flags['app-root-path']).trim() !== '') {
+            preset.appRootPath = String(flags['app-root-path']).trim();
+        }
+        if (flags['app-port'] !== undefined && String(flags['app-port']).trim() !== '') {
+            preset.appPort = String(flags['app-port']).trim();
+        }
+        if (flags['storage-path'] !== undefined && String(flags['storage-path']).trim() !== '') {
+            preset.storagePath = String(flags['storage-path']).trim();
+        }
+        if (flags['root-username'] !== undefined) {
+            preset.rootUsername = String(flags['root-username'] ?? '').trim();
+        }
+        if (flags['root-email'] !== undefined) {
+            preset.rootEmail = String(flags['root-email'] ?? '').trim();
+        }
+        if (flags['root-password'] !== undefined) {
+            preset.rootPassword = String(flags['root-password'] ?? '');
+        }
+        if (flags['root-nickname'] !== undefined) {
+            preset.rootNickname = String(flags['root-nickname'] ?? '').trim();
+        }
+        if (flags['db-dialect'] !== undefined && String(flags['db-dialect']).trim() !== '') {
+            preset.dbDialect = String(flags['db-dialect']).trim();
+        }
+        if (flags['db-host'] !== undefined && String(flags['db-host']).trim() !== '') {
+            preset.dbHost = String(flags['db-host']).trim();
+        }
+        if (flags['db-port'] !== undefined && String(flags['db-port']).trim() !== '') {
+            preset.dbPort = String(flags['db-port']).trim();
+        }
+        if (flags['db-database'] !== undefined && String(flags['db-database']).trim() !== '') {
+            preset.dbDatabase = String(flags['db-database']).trim();
+        }
+        if (flags['db-user'] !== undefined && String(flags['db-user']).trim() !== '') {
+            preset.dbUser = String(flags['db-user']).trim();
+        }
+        if (flags['db-password'] !== undefined) {
+            preset.dbPassword = String(flags['db-password'] ?? '');
+        }
+        if (argvHasToken(argv, ['--fetch-source'])) {
+            preset.fetchSource = Boolean(flags['fetch-source']);
+        }
+        if (flags.source !== undefined && String(flags.source).trim() !== '') {
+            preset.source = String(flags.source).trim();
+        }
+        if (flags.version !== undefined) {
+            preset.version = String(flags.version).trim() || 'latest';
+        }
+        if (flags['docker-registry'] !== undefined && String(flags['docker-registry']).trim() !== '') {
+            preset.dockerRegistry = String(flags['docker-registry']).trim();
+        }
+        if (flags['docker-platform'] !== undefined && String(flags['docker-platform']).trim() !== '') {
+            preset.dockerPlatform = String(flags['docker-platform']).trim();
+        }
+        if (flags['output-dir'] !== undefined && String(flags['output-dir']).trim() !== '') {
+            preset.outputDir = String(flags['output-dir']).trim();
+        }
+        if (flags['git-url'] !== undefined && String(flags['git-url']).trim() !== '') {
+            preset.gitUrl = String(flags['git-url']).trim();
+        }
+        if (flags['npm-registry'] !== undefined) {
+            preset.npmRegistry = String(flags['npm-registry'] ?? '');
+        }
+        if (argvHasToken(argv, ['--replace', '-r'])) {
+            preset.replace = Boolean(flags.replace);
+        }
+        if (argvHasToken(argv, ['--dev-dependencies', '--no-dev-dependencies', '-D'])) {
+            preset.devDependencies = Boolean(flags['dev-dependencies']);
+        }
+        if (argvHasToken(argv, ['--docker-save', '--no-docker-save'])) {
+            preset.dockerSave = Boolean(flags['docker-save']);
+        }
+        if (argvHasToken(argv, ['--build', '--no-build'])) {
+            preset.build = Boolean(flags.build);
+        }
+        if (argvHasToken(argv, ['--build-dts', '--no-build-dts'])) {
+            preset.buildDts = Boolean(flags['build-dts']);
+        }
+        if (argvHasToken(argv, ['--builtin-db'])) {
+            preset.builtinDb = Boolean(flags['builtin-db']);
+        }
+        if (argvHasToken(argv, ['--install-skills'])) {
+            preset.installSkills = Boolean(flags['install-skills']);
+        }
+        else if (this.hasAgentsDirInCwd()) {
+            preset.installSkills = false;
+        }
+        return preset;
+    }
+    hasAgentsDirInCwd() {
+        return existsSync(path.resolve(process.cwd(), '.agents'));
+    }
+    async persistManagedEnvConfig(results) {
+        const envName = String(results.appName ?? DEFAULT_INIT_APP_NAME).trim() || DEFAULT_INIT_APP_NAME;
+        const appPort = String(results.appPort ?? '').trim();
+        const source = String(results.source ?? '').trim();
+        const version = String(results.version ?? '').trim();
+        const dockerRegistry = String(results.dockerRegistry ?? '').trim();
+        const dockerPlatform = String(results.dockerPlatform ?? '').trim();
+        const gitUrl = String(results.gitUrl ?? '').trim();
+        const npmRegistry = String(results.npmRegistry ?? '').trim();
+        const appRootPath = String(results.appRootPath ?? '').trim();
+        const storagePath = String(results.storagePath ?? '').trim();
+        const dbDialect = String(results.dbDialect ?? '').trim();
+        const dbHost = String(results.dbHost ?? '').trim();
+        const dbPort = String(results.dbPort ?? '').trim();
+        const dbDatabase = String(results.dbDatabase ?? '').trim();
+        const dbUser = String(results.dbUser ?? '').trim();
+        const dbPassword = String(results.dbPassword ?? '');
+        await upsertEnv(envName, {
+            ...(appPort ? { baseUrl: `http://127.0.0.1:${appPort}/api` } : {}),
+            ...(source ? { source } : {}),
+            ...(version ? { downloadVersion: version } : {}),
+            ...(dockerRegistry ? { dockerRegistry } : {}),
+            ...(dockerPlatform ? { dockerPlatform } : {}),
+            ...(gitUrl ? { gitUrl } : {}),
+            ...(npmRegistry ? { npmRegistry } : {}),
+            ...(appRootPath ? { appRootPath } : {}),
+            ...(storagePath ? { storagePath } : {}),
+            ...(appPort ? { appPort } : {}),
+            ...(results.devDependencies !== undefined ? { devDependencies: Boolean(results.devDependencies) } : {}),
+            ...(results.build !== undefined ? { build: Boolean(results.build) } : {}),
+            ...(results.buildDts !== undefined ? { buildDts: Boolean(results.buildDts) } : {}),
+            ...(results.builtinDb !== undefined ? { builtinDb: Boolean(results.builtinDb) } : {}),
+            ...(dbDialect ? { dbDialect } : {}),
+            ...(dbHost ? { dbHost } : {}),
+            ...(dbPort ? { dbPort } : {}),
+            ...(dbDatabase ? { dbDatabase } : {}),
+            ...(dbUser ? { dbUser } : {}),
+            ...(dbPassword ? { dbPassword } : {}),
+        }, { scope: CONFIG_SCOPE });
+    }
+    buildEnvAddArgv(results) {
+        const argv = [String(results.appName ?? DEFAULT_INIT_APP_NAME)];
+        argv.push('--no-intro');
+        argv.push('--scope', CONFIG_SCOPE);
+        argv.push('--api-base-url', String(results.apiBaseUrl ?? DEFAULT_INIT_API_BASE_URL));
+        argv.push('--auth-type', String(results.authType ?? 'oauth'));
+        if (results.authType === 'token') {
+            argv.push('--access-token', String(results.accessToken ?? ''));
+        }
+        return argv;
+    }
+    buildInstallArgv(results, flags, options) {
+        const argv = ['--no-intro'];
+        if (options?.nonInteractive ?? true) {
+            argv.unshift('-y');
+        }
+        const processArgv = process.argv.slice(2);
+        const envName = String(results.appName ?? DEFAULT_INIT_APP_NAME).trim() || DEFAULT_INIT_APP_NAME;
+        const source = String(results.source ?? '').trim();
+        argv.push('--env', envName);
+        if (options?.resume) {
+            argv.push('--resume');
+        }
+        const lang = String(results.lang ?? '').trim();
+        if (lang) {
+            argv.push('--lang', lang);
+        }
+        const appRootPath = String(results.appRootPath ?? '').trim();
+        if (appRootPath) {
+            argv.push('--app-root-path', appRootPath);
+        }
+        const appPort = String(results.appPort ?? '').trim();
+        if (appPort && (!flags.yes || argvHasToken(processArgv, ['--app-port']) || appPort !== '13000')) {
+            argv.push('--app-port', appPort);
+        }
+        const storagePath = String(results.storagePath ?? '').trim();
+        if (storagePath) {
+            argv.push('--storage-path', storagePath);
+        }
+        if (Boolean(flags.force)) {
+            argv.push('--force');
+        }
+        if (Boolean(results.fetchSource)) {
+            argv.push('--fetch-source');
+            if (source) {
+                argv.push('--source', source);
+            }
+            const version = String(results.version ?? '').trim();
+            if (version) {
+                argv.push('--version', version);
+            }
+            const outputDir = String(results.outputDir ?? '').trim();
+            if (outputDir) {
+                argv.push('--output-dir', outputDir);
+            }
+            const gitUrl = String(results.gitUrl ?? '').trim();
+            if (gitUrl) {
+                argv.push('--git-url', gitUrl);
+            }
+            const dockerRegistry = String(results.dockerRegistry ?? '').trim();
+            if (dockerRegistry) {
+                argv.push('--docker-registry', dockerRegistry);
+            }
+            const dockerPlatform = String(results.dockerPlatform ?? '').trim();
+            if (dockerPlatform) {
+                argv.push('--docker-platform', dockerPlatform);
+            }
+            const npmRegistry = String(results.npmRegistry ?? '').trim();
+            if (npmRegistry) {
+                argv.push('--npm-registry', npmRegistry);
+            }
+            if (Boolean(results.replace)) {
+                argv.push('--replace');
+            }
+            if (Boolean(results.devDependencies)) {
+                argv.push('--dev-dependencies');
+            }
+            if (Boolean(results.dockerSave)) {
+                argv.push('--docker-save');
+            }
+            if (results.build !== undefined && !Boolean(results.build)) {
+                argv.push('--no-build');
+            }
+            else if (argvHasToken(processArgv, ['--build', '--no-build']) && flags.build === false) {
+                argv.push('--no-build');
+            }
+            if (Boolean(results.buildDts)) {
+                argv.push('--build-dts');
+            }
+        }
+        const builtinDb = Boolean(results.builtinDb);
+        if (builtinDb) {
+            argv.push('--builtin-db');
+        }
+        const dbDialect = String(results.dbDialect ?? '').trim();
+        if (dbDialect) {
+            argv.push('--db-dialect', dbDialect);
+        }
+        const dbHost = String(results.dbHost ?? '').trim();
+        if (dbHost) {
+            argv.push('--db-host', dbHost);
+        }
+        const dbPort = String(results.dbPort ?? '').trim();
+        const dbPortWasProvided = argvHasToken(processArgv, ['--db-port']);
+        const dockerBuiltinDbPortIsHidden = builtinDb && source === 'docker';
+        const dbDefaultPort = defaultDbPortForDialect(dbDialect);
+        if (dbPort
+            && (!dockerBuiltinDbPortIsHidden || dbPortWasProvided)
+            && (!flags.yes || dbPortWasProvided || dbPort !== dbDefaultPort)) {
+            argv.push('--db-port', dbPort);
+        }
+        const dbDatabase = String(results.dbDatabase ?? '').trim();
+        if (dbDatabase) {
+            argv.push('--db-database', dbDatabase);
+        }
+        const dbUser = String(results.dbUser ?? '').trim();
+        if (dbUser) {
+            argv.push('--db-user', dbUser);
+        }
+        const dbPassword = String(results.dbPassword ?? '');
+        if (dbPassword) {
+            argv.push('--db-password', dbPassword);
+        }
+        const rootUsername = String(results.rootUsername ?? '').trim();
+        if (rootUsername) {
+            argv.push('--root-username', rootUsername);
+        }
+        const rootEmail = String(results.rootEmail ?? '').trim();
+        if (rootEmail) {
+            argv.push('--root-email', rootEmail);
+        }
+        const rootPassword = String(results.rootPassword ?? '');
+        if (rootPassword) {
+            argv.push('--root-password', rootPassword);
+        }
+        const rootNickname = String(results.rootNickname ?? '').trim();
+        if (rootNickname) {
+            argv.push('--root-nickname', rootNickname);
+        }
+        return argv;
+    }
+    buildResumeInstallArgv(flags) {
+        return this.buildInstallArgv(this.buildPresetValuesFromFlags(flags), flags, {
+            nonInteractive: Boolean(flags.yes),
+            resume: true,
+        });
+    }
+}