@nocobase/cli 2.1.0-alpha.19 → 2.1.0-alpha.20

package/dist/commands/env/add.js

@@ -1,53 +1,198 @@
-import { Command, Flags } from '@oclif/core';
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import * as p from '@clack/prompts';
 import { upsertEnv } from '../../lib/auth-store.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
-import { isInteractiveTerminal, printVerbose, promptText, setVerboseMode } from '../../lib/ui.js';
+import { isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
 export default class EnvAdd extends Command {
-    static summary = 'Add or update a NocoBase environment';
-    static id = 'env add';
+    static summary = 'Save a named NocoBase API endpoint (token or OAuth), then switch the CLI to use it';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> local',
+        '<%= config.bin %> <%= command.id %> local --scope project --api-base-url http://localhost:13000/api --auth-type oauth',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Label for this environment (optional first argument; in a TTY, prompted when omitted; required when not using a TTY)',
+            required: false,
+        }),
+    };
     static flags = {
+        env: Flags.string({
+            char: 'e',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
+        }),
         verbose: Flags.boolean({
-            description: 'Show detailed progress output',
+            description: 'Print detailed progress while writing config',
             default: false,
         }),
-        name: Flags.string({
-            description: 'Environment name',
-            default: 'default',
-        }),
         scope: Flags.string({
             char: 's',
-            description: 'Config scope',
+            description: 'Where to store env config: project (.nocobase in the repo) or global (user-level); prompted in a TTY when omitted',
             options: ['project', 'global'],
         }),
-        'base-url': Flags.string({
-            description: 'NocoBase API base URL, for example http://localhost:13000/api',
+        'api-base-url': Flags.string({
+            char: 'u',
+            aliases: ['base-url'],
+            description: 'Root URL for HTTP API calls, including the /api prefix (e.g. http://localhost:13000/api); prompted in a TTY when omitted',
         }),
-        token: Flags.string({
+        'auth-type': Flags.string({
+            char: 'a',
+            description: 'Authentication: token (API key) or oauth (browser login via `nb env auth`); prompted in a TTY when omitted',
+            options: ['token', 'oauth'],
+        }),
+        'access-token': Flags.string({
             char: 't',
-            description: 'API key',
+            aliases: ['token'],
+            description: 'API key or access token when using --auth-type token (prompted in a TTY when omitted)',
         }),
     };
+    exitCancelled() {
+        p.cancel('Cancelled.');
+        this.exit(0);
+    }
     async run() {
-        const { flags } = await this.parse(EnvAdd);
+        const { args, flags } = await this.parse(EnvAdd);
         setVerboseMode(flags.verbose);
-        const name = flags.name || 'default';
-        const scope = flags.scope;
-        const baseUrl = flags['base-url'] ||
-            (isInteractiveTerminal()
-                ? await promptText('Base URL', { defaultValue: 'http://localhost:13000/api' })
-                : '');
-        if (Object.keys(flags).includes('token') && !flags.token) {
-            flags.token = isInteractiveTerminal() ? await promptText('API key (optional)', { secret: true }) : '';
-            if (!flags.token) {
-                this.error('API key cannot be empty if --token flag is provided without a value.');
-            }
-        }
-        const token = flags.token;
-        if (!baseUrl) {
-            this.error('Missing base URL. Pass `--base-url <url>` or run in a TTY to enter it interactively.');
-        }
-        printVerbose(`Saving env "${name}" with base URL ${baseUrl}`);
-        await upsertEnv(name, baseUrl, token, { scope });
-        this.log(`Saved env "${name}" and set it as current${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+        const nameArg = args.name?.trim();
+        const nameFlag = flags.env?.trim() || undefined;
+        if (nameArg && nameFlag && nameArg !== nameFlag) {
+            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+        }
+        let name = nameArg || nameFlag || undefined;
+        let scope = flags.scope;
+        let baseUrl = flags['api-base-url'] ?? flags['base-url'];
+        let authType = flags['auth-type'];
+        const interactive = isInteractiveTerminal();
+        if (!interactive) {
+            const missing = [];
+            if (!name?.trim()) {
+                missing.push('<name> (first argument or --env)');
+            }
+            if (!scope) {
+                missing.push('--scope');
+            }
+            if (!baseUrl) {
+                missing.push('--api-base-url');
+            }
+            if (!authType) {
+                missing.push('--auth-type');
+            }
+            if (missing.length > 0) {
+                this.error(`Non-interactive mode requires: ${missing.join(', ')}. Example: nb env add -e local --scope project --api-base-url http://localhost:13000/api --auth-type oauth`);
+            }
+        }
+        else {
+            if (!name?.trim()) {
+                const answer = await p.text({
+                    message: 'Environment name',
+                    placeholder: 'default',
+                    defaultValue: 'default',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                name = answer;
+            }
+            if (!scope) {
+                const answer = await p.select({
+                    message: 'Where should this env be stored?',
+                    options: [
+                        { value: 'project', label: 'Project', hint: '.nocobase in this repo' },
+                        { value: 'global', label: 'Global', hint: 'user-level config' },
+                    ],
+                    initialValue: 'project',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                scope = answer;
+            }
+            if (!baseUrl) {
+                const answer = await p.text({
+                    message: 'API base URL',
+                    placeholder: 'http://localhost:13000/api',
+                    defaultValue: 'http://localhost:13000/api',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                baseUrl = answer;
+            }
+            if (!authType) {
+                const answer = await p.select({
+                    message: 'How do you want to authenticate?',
+                    options: [
+                        { value: 'oauth', label: 'OAuth (browser login)', hint: 'runs nb env auth after save' },
+                        { value: 'token', label: 'API token / API key' },
+                    ],
+                    initialValue: 'oauth',
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                authType = answer;
+            }
+        }
+        const accessTokenKeys = ['access-token', 'token'];
+        const accessTokenFlagPresent = accessTokenKeys.some((key) => Object.prototype.hasOwnProperty.call(flags, key));
+        if (accessTokenFlagPresent && !flags['access-token'] && !flags['token']) {
+            if (!interactive) {
+                this.error('When passing --access-token (or --token) without a value, run in a TTY or provide the token as the flag value.');
+            }
+            const prompted = await p.password({
+                message: 'Access token / API key',
+                validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
+            });
+            if (p.isCancel(prompted)) {
+                this.exitCancelled();
+            }
+            flags['access-token'] = prompted;
+        }
+        let token = flags['access-token'] ?? flags['token'];
+        if (!name?.trim()) {
+            this.error('Environment name cannot be empty.');
+        }
+        if (!baseUrl?.trim()) {
+            this.error('API base URL cannot be empty.');
+        }
+        name = name.trim();
+        baseUrl = baseUrl.trim();
+        if (authType === 'token') {
+            if (!token && interactive) {
+                const answer = await p.password({
+                    message: 'Access token / API key',
+                    validate: (value) => (value.trim() ? undefined : 'Token cannot be empty'),
+                });
+                if (p.isCancel(answer)) {
+                    this.exitCancelled();
+                }
+                token = answer;
+            }
+            if (!token?.trim()) {
+                this.error('Auth type token requires an access token. Pass `--access-token`, or run in a TTY to enter it.');
+            }
+            printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (token auth)`);
+            await upsertEnv(name, { baseUrl, accessToken: token }, { scope });
+            this.log(`Saved env "${name}" and set it as current${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
+            return;
+        }
+        printVerbose(`Saving env "${name}" with API base URL ${baseUrl} (OAuth next)`);
+        await upsertEnv(name, { baseUrl }, { scope });
+        this.log(`Saved env "${name}"${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}. Starting OAuth login (\`nb env auth ${name}\`).`);
+        const authArgv = [name];
+        if (scope) {
+            authArgv.push('-s', scope);
+        }
+        await this.config.runCommand('env:auth', authArgv);
     }
 }

package/dist/commands/env/auth.js

@@ -1,14 +1,33 @@
-import { Command, Flags } from '@oclif/core';
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName } from '../../lib/auth-store.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
 import { authenticateEnvWithOauth } from '../../lib/env-auth.js';
 import { failTask, startTask, succeedTask } from '../../lib/ui.js';
 export default class EnvAuth extends Command {
     static summary = 'Authenticate an environment with OAuth';
-    static id = 'env auth';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            required: true,
+        }),
+    };
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'Environment name',
+            hidden: true,
+            deprecated: true,
+            description: 'Environment name (same as the optional positional argument; for compatibility with -e/--env on other commands)',
         }),
         scope: Flags.string({
             char: 's',
@@ -17,13 +36,19 @@ export default class EnvAuth extends Command {
         }),
     };
     async run() {
-        const { flags } = await this.parse(EnvAuth);
+        const { args, flags } = await this.parse(EnvAuth);
         const scope = flags.scope;
-        const envLabel = flags.env ?? 'current';
+        const nameArg = args.name?.trim();
+        const nameFlag = flags.env?.trim() || undefined;
+        if (nameArg && nameFlag && nameArg !== nameFlag) {
+            this.error(`Environment name was given both as the argument ("${nameArg}") and as --env ("${nameFlag}"); use only one.`);
+        }
+        const envName = nameArg || nameFlag || undefined;
+        const envLabel = envName ?? (await getCurrentEnvName({ scope }));
         startTask(`Authenticating env: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
         try {
             await authenticateEnvWithOauth({
-                envName: flags.env,
+                envName,
                 scope,
             });
             succeedTask(`Authenticated env "${envLabel}" with OAuth${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);

package/dist/commands/env/list.js

@@ -1,10 +1,20 @@
+/**
+ * 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 { listEnvs } from '../../lib/auth-store.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
 import { renderTable } from '../../lib/ui.js';
 export default class EnvList extends Command {
     static summary = 'List configured environments';
-    static id = 'env list';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+    ];
     static flags = {
         scope: Flags.string({
             char: 's',
@@ -19,7 +29,7 @@ export default class EnvList extends Command {
         const names = Object.keys(envs).sort();
         if (!names.length) {
             this.log(`No envs configured${scope ? ` in ${formatCliHomeScope(scope)} scope` : ''}.`);
-            this.log('Run `nb env add --name <name> --base-url <url>` to add one.');
+            this.log('Run `nb env add <name> --base-url <url>` to add one.');
             return;
         }
         const rows = names.map((name) => {

package/dist/commands/env/remove.js

@@ -1,10 +1,21 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
 import { getCurrentEnvName, removeEnv } from '../../lib/auth-store.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
 import { confirmAction, isInteractiveTerminal, printVerbose, setVerboseMode } from '../../lib/ui.js';
 export default class EnvRemove extends Command {
-    static id = 'env remove';
     static summary = 'Remove a configured environment';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> staging',
+        '<%= config.bin %> <%= command.id %> staging -f',
+    ];
     static flags = {
         force: Flags.boolean({
             char: 'f',

package/dist/commands/env/update.js

@@ -1,22 +1,36 @@
+/**
+ * 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 path from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { Command, Flags } from '@oclif/core';
+import { Args, Command, Flags } from '@oclif/core';
+import { getCurrentEnvName } from '../../lib/auth-store.js';
 import { updateEnvRuntime } from '../../lib/bootstrap.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
 import { failTask, startTask, succeedTask } from '../../lib/ui.js';
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 export default class EnvUpdate extends Command {
     static summary = 'Refresh an environment runtime from swagger:get and persist connection overrides';
-    static id = 'env update';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> prod',
+    ];
+    static args = {
+        name: Args.string({
+            description: 'Environment name (omit to use the current env)',
+            required: false,
+        }),
+    };
     static flags = {
         verbose: Flags.boolean({
             description: 'Show detailed progress output',
             default: false,
         }),
-        env: Flags.string({
-            char: 'e',
-            description: 'Environment name',
-        }),
         scope: Flags.string({
             char: 's',
             description: 'Config scope',
@@ -34,13 +48,14 @@ export default class EnvUpdate extends Command {
         }),
     };
     async run() {
-        const { flags } = await this.parse(EnvUpdate);
+        const { args, flags } = await this.parse(EnvUpdate);
         const scope = flags.scope;
-        const envLabel = flags.env ?? 'current';
+        const envName = args.name;
+        const envLabel = envName ?? (await getCurrentEnvName({ scope }));
         startTask(`Updating env runtime: ${envLabel}${scope ? ` (${formatCliHomeScope(scope)})` : ''}`);
         try {
             const runtime = await updateEnvRuntime({
-                envName: flags.env,
+                envName,
                 scope,
                 baseUrl: flags['base-url'],
                 role: flags.role,

package/dist/commands/env/use.js

@@ -1,9 +1,19 @@
+/**
+ * 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 { Args, Command, Flags } from '@oclif/core';
 import { setCurrentEnv } from '../../lib/auth-store.js';
 import { formatCliHomeScope } from '../../lib/cli-home.js';
 export default class EnvUse extends Command {
     static summary = 'Switch the current environment';
-    static id = 'env use';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> local',
+    ];
     static flags = {
         scope: Flags.string({
             char: 's',

package/dist/commands/init.js

@@ -0,0 +1,186 @@
+/**
+ * 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 { stdin as stdinStream, stdout as stdoutStream } from 'node:process';
+import { buildEnvAddArgv, InitWizardCancelledError, runInitBrowserWizard, } from "../lib/init-browser-wizard.js";
+import { run } from "../lib/run-npm.js";
+export default class Init extends Command {
+    static summary = 'Initialize the NocoBase AI setup environment';
+    static description = `Initialize the current workspace for NocoBase CLI and agent workflows. You only run nb init; the following runs inside this command (not as separate manual steps):
+
+1. Optionally install NocoBase agent skills (\`npx -y skills add nocobase/skills\`)—you are prompted when using a TTY.
+2. If you already have a NocoBase application (anywhere): runs \`nb env add\` only (\`nb install\` is skipped).
+3. If not: runs \`nb install\` only (\`nb env add\` is not run afterward; configure the CLI with \`nb env add\` when you need it).
+
+Internal ordering: (skills?) → (already have an app? → env add | install only).
+
+Use \`-y\` / \`--yes\` to skip init prompts (defaults: install skills, then \`nb install\` only—same as choosing the first option, no existing app). When you choose an existing app in a TTY, \`nb env add\` may still prompt for URL and auth.
+
+Use \`--ui\` to open a **browser** wizard (local HTTP server; default bind \`0.0.0.0\`, random port). Use \`--ui-host\` / \`--ui-port\` to override. The opened URL uses \`127.0.0.1\` when the bind address is all-interfaces. It can collect \`nb env add\` fields when you link an existing app, so the terminal env wizard is skipped. Cannot be combined with \`--yes\`.`;
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> --ui',
+        '<%= config.bin %> <%= command.id %> --ui --ui-host 127.0.0.1 --ui-port 3000',
+        '<%= config.bin %> <%= command.id %> -y',
+    ];
+    static flags = {
+        yes: Flags.boolean({
+            char: 'y',
+            description: 'Skip all prompts',
+            default: false,
+        }),
+        ui: Flags.boolean({
+            description: 'Open a browser-based setup wizard (local HTTP server; not valid with --yes)',
+            default: false,
+        }),
+        'ui-host': Flags.string({
+            description: 'Bind address for the --ui wizard HTTP server (default 0.0.0.0; only with --ui)',
+        }),
+        'ui-port': Flags.integer({
+            description: 'TCP port for the --ui wizard; 0 = OS-assigned ephemeral port (default 0; only with --ui)',
+            min: 0,
+            max: 65535,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Init);
+        if (flags.ui && flags.yes) {
+            this.error('--ui cannot be used with --yes.');
+        }
+        if (!flags.ui &&
+            (flags['ui-host'] !== undefined || flags['ui-port'] !== undefined)) {
+            this.error('--ui-host and --ui-port require --ui.');
+        }
+        const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY);
+        const useBrowserUi = Boolean(flags.ui);
+        if (useBrowserUi) {
+            if (interactive) {
+                p.intro(`${pc.bold('nb init')} ${pc.dim('— browser wizard')}`);
+            }
+            else {
+                this.log('nb init — browser wizard');
+            }
+            this.log('Your browser should open; complete the form there to continue.');
+        }
+        else {
+            p.intro('Initialize the NocoBase AI setup environment');
+        }
+        /** Whether `nb install` / follow-up should avoid terminal prompts (`-y`). */
+        const skipInstallPrompts = Boolean(flags.yes) || !interactive;
+        let installSkills = true;
+        let hasNocobase = false;
+        /** When set, \`nb env add\` is invoked with these argv (from \`--ui\` form). */
+        let envAddArgvFromUi;
+        if (flags.yes) {
+            p.log.info('Skipping prompts (--yes): will install NocoBase agent skills.');
+            installSkills = true;
+            hasNocobase = false;
+            p.log.info('Skipping prompts (--yes): will run nb install only (same default as "I don\'t have a NocoBase application yet").');
+        }
+        else if (useBrowserUi) {
+            try {
+                const choice = await runInitBrowserWizard((line) => this.log(line), {
+                    bindHost: flags['ui-host']?.trim() || '0.0.0.0',
+                    port: flags['ui-port'] ?? 0,
+                });
+                installSkills = choice.installSkills;
+                hasNocobase = choice.hasNocobase;
+                if (choice.envAdd) {
+                    envAddArgvFromUi = buildEnvAddArgv(choice.envAdd);
+                }
+            }
+            catch (error) {
+                if (error instanceof InitWizardCancelledError) {
+                    if (interactive) {
+                        p.cancel(error.message);
+                    }
+                    else {
+                        this.log(error.message);
+                    }
+                    this.exit(0);
+                }
+                throw error;
+            }
+        }
+        else if (interactive) {
+            const skillsAnswer = await p.confirm({
+                message: 'Install NocoBase agent skills (nocobase/skills) for Cursor / Codex workflows?',
+                initialValue: true,
+            });
+            if (p.isCancel(skillsAnswer)) {
+                p.cancel('Init cancelled.');
+                this.exit(0);
+            }
+            installSkills = skillsAnswer;
+            const answer = await p.select({
+                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',
+            });
+            if (p.isCancel(answer)) {
+                p.cancel('Init cancelled.');
+                this.exit(0);
+            }
+            hasNocobase = answer === 'yes';
+        }
+        else {
+            p.log.warn('Non-interactive terminal: will install NocoBase agent skills (skip is not available without a TTY).');
+            installSkills = true;
+            hasNocobase = false;
+            p.log.warn('Non-interactive terminal: assuming you do not already have a NocoBase app (will run nb install only).');
+        }
+        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');
+                if (useBrowserUi && !envAddArgvFromUi) {
+                    this.error('Browser wizard did not supply env add options.');
+                }
+                const envArgv = envAddArgvFromUi ??
+                    (interactive ? ['--scope', 'project'] : ['default', '--scope', 'project']);
+                await this.config.runCommand('env:add', envArgv);
+            }
+            else {
+                p.log.step('Running nb install');
+                await this.config.runCommand('install', skipInstallPrompts ? ['-e', 'local', '-y'] : []);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            p.outro(pc.red(message));
+            this.error(message);
+        }
+        p.outro('Workspace init finished.');
+    }
+}