@nocobase/cli 2.1.0-beta.35 → 2.1.0-beta.37

package/dist/commands/license/activate.js

@@ -21,11 +21,11 @@ async function promptActivationMode() {
         return await select({
             message: 'How do you want to activate the license?',
             choices: [
-                { value: 'key', name: 'Use an existing license key' },
                 { value: 'online', name: 'Request and activate a license online' },
+                { value: 'key', name: 'Use an existing license key' },
                 { value: 'cancel', name: 'Cancel' },
             ],
-            default: 'key',
+            default: 'online',
         });
     }
     catch {
@@ -70,7 +70,7 @@ async function promptLicenseKeyInput() {
         return {};
     }
 }
-async function promptOnlineActivationInput(initial) {
+async function promptOnlineActivationInput(initial, defaultAppName) {
     let account = String(initial.account ?? '').trim();
     if (!account) {
         try {
@@ -107,8 +107,10 @@ async function promptOnlineActivationInput(initial) {
     let appName = String(initial.appName ?? '').trim();
     if (!appName) {
         try {
+            const resolvedDefaultAppName = String(defaultAppName ?? '').trim();
             const answer = await input({
                 message: 'Application name',
+                default: resolvedDefaultAppName || undefined,
                 validate: (value) => String(value ?? '').trim() ? true : 'Application name is required.',
             });
             appName = String(answer ?? '').trim();
@@ -259,7 +261,7 @@ export default class LicenseActivate extends Command {
                 if (!isInteractiveTerminal()) {
                     this.error('Online activation requires --account, --password, and --desc when not using a TTY.');
                 }
-                const prompted = await promptOnlineActivationInput(initialOnline);
+                const prompted = await promptOnlineActivationInput(initialOnline, runtime.envName);
                 if (!prompted) {
                     return;
                 }

package/dist/commands/source/publish.js

@@ -10,6 +10,11 @@ import { Command, Flags } from '@oclif/core';
 import { buildSuggestedInitCommand, publishSourceSnapshot } from '../../lib/source-publish.js';
 import { failTask, printInfo, startTask, succeedTask } from '../../lib/ui.js';
 function formatPublishFailure(message) {
+    if (message.includes('The specified --cwd does not exist:')
+        || message.includes('The specified --cwd is not a directory:')
+        || message.includes('Couldn\'t find a NocoBase source project from --cwd:')) {
+        return message;
+    }
     return [
         'Couldn\'t publish a source snapshot.',
         'Check that Docker is running, the target npm registry is reachable, and the current directory is a NocoBase source repo.',
@@ -20,6 +25,8 @@ export default class SourcePublish extends Command {
     static description = 'Publish the current NocoBase source repo as a snapshot version to an npm registry for install testing.';
     static examples = [
         '<%= config.bin %> <%= command.id %> --snapshot',
+        '<%= config.bin %> <%= command.id %> --snapshot --no-build',
+        '<%= config.bin %> <%= command.id %> --snapshot --build-dts',
         '<%= config.bin %> <%= command.id %> --snapshot --cwd /path/to/nocobase/source',
         '<%= config.bin %> <%= command.id %> --snapshot --npm-registry=http://127.0.0.1:4873',
         '<%= config.bin %> <%= command.id %> --snapshot --json',
@@ -38,6 +45,14 @@ export default class SourcePublish extends Command {
             description: 'Source repository path. Defaults to the nearest detected NocoBase source root from the current working directory',
             required: false,
         }),
+        'no-build': Flags.boolean({
+            description: 'Skip building the source repo before snapshot versioning and publish',
+            default: false,
+        }),
+        'build-dts': Flags.boolean({
+            description: 'Generate TypeScript declaration files during the source build',
+            default: false,
+        }),
         json: Flags.boolean({
             description: 'Print the publish result as JSON',
             default: false,
@@ -59,6 +74,8 @@ export default class SourcePublish extends Command {
             const result = await publishSourceSnapshot({
                 cwd: flags.cwd,
                 npmRegistry: flags['npm-registry'],
+                build: !flags['no-build'],
+                buildDts: flags['build-dts'],
                 verbose: flags.verbose,
             });
             if (flags.json) {

package/dist/commands/v1.js

@@ -0,0 +1,210 @@
+/**
+ * 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 } from '@oclif/core';
+import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, runDockerNocoBaseCommand, runLocalNocoBaseCommand, } from '../lib/app-runtime.js';
+import { ensureCrossEnvConfirmed, hasExplicitEnvSelection } from '../lib/env-guard.js';
+import { announceTargetEnv } from '../lib/ui.js';
+const SILENT_LIKE_PASSTHROUGH_FLAGS = new Set(['--help', '-h', '--silent']);
+const SILENT_RUNTIME_ENV_VARS = {
+    LOGGER_SILENT: 'true',
+    NODE_NO_WARNINGS: '1',
+};
+const SILENT_STDERR_FILTERS = [
+    /^\(node:\d+\) \[DEP0040\] DeprecationWarning: The `punycode` module is deprecated\..*$/,
+    /^\(Use `node --trace-deprecation .*$/,
+    /^About to overwrite ArrayBuffer\.prototype properties /,
+];
+function parseBridgeArgv(argv) {
+    let requestedEnv;
+    let yes = false;
+    const passthroughArgs = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const token = argv[index];
+        if (token === '--') {
+            passthroughArgs.push(...argv.slice(index + 1));
+            break;
+        }
+        if (token === '--env') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `--env`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('--env=')) {
+            requestedEnv = token.slice('--env='.length).trim() || undefined;
+            continue;
+        }
+        if (token === '-e') {
+            const value = argv[index + 1];
+            if (!value || value === '--') {
+                throw new Error('Missing value for `-e`.');
+            }
+            requestedEnv = value.trim() || undefined;
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-e') && token.length > 2) {
+            requestedEnv = token.slice(2).trim() || undefined;
+            continue;
+        }
+        if (token === '--yes') {
+            yes = true;
+            continue;
+        }
+        passthroughArgs.push(...argv.slice(index));
+        break;
+    }
+    return {
+        requestedEnv,
+        yes,
+        passthroughArgs,
+    };
+}
+function formatHttpEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'This env only has an API connection, so the v1 bridge is not available here.',
+        'Use a local or Docker env instead.',
+    ].join('\n');
+}
+function formatSshEnvError(envName) {
+    return [
+        `Can't run \`nb v1\` for "${envName}" yet.`,
+        'SSH env support is reserved but not implemented yet.',
+        'Use a local or Docker env right now.',
+    ].join('\n');
+}
+function hasSilentLikePassthrough(args) {
+    return args.some((arg) => SILENT_LIKE_PASSTHROUGH_FLAGS.has(arg));
+}
+function shouldFilterSilentStderrLine(line) {
+    const normalized = line.replace(/\r$/, '');
+    return SILENT_STDERR_FILTERS.some((pattern) => pattern.test(normalized));
+}
+function createSilentBridgeOptions() {
+    let pendingStderr = '';
+    const flushBufferedStderr = (force) => {
+        while (true) {
+            const newlineIndex = pendingStderr.indexOf('\n');
+            if (newlineIndex === -1) {
+                break;
+            }
+            const line = pendingStderr.slice(0, newlineIndex);
+            pendingStderr = pendingStderr.slice(newlineIndex + 1);
+            if (!shouldFilterSilentStderrLine(line)) {
+                process.stderr.write(`${line}\n`);
+            }
+        }
+        if (force && pendingStderr) {
+            if (!shouldFilterSilentStderrLine(pendingStderr)) {
+                process.stderr.write(pendingStderr);
+            }
+            pendingStderr = '';
+        }
+    };
+    return {
+        commandOptions: {
+            stdio: 'pipe',
+            env: {
+                ...SILENT_RUNTIME_ENV_VARS,
+            },
+            onStdout: (chunk) => {
+                process.stdout.write(chunk);
+            },
+            onStderr: (chunk) => {
+                pendingStderr += chunk;
+                flushBufferedStderr(false);
+            },
+        },
+        flush: () => {
+            flushBufferedStderr(true);
+        },
+    };
+}
+export default class V1 extends Command {
+    static hidden = true;
+    static strict = false;
+    static summary = 'Forward commands to the selected env through the v1 bridge';
+    static description = 'Forward v1-compatible commands to the selected env. Defaults to the current env when `--env` is omitted. Local envs run `nocobase-v1`, and Docker envs run inside the saved app container. Bridge flags (`--env`, `--yes`) must appear before the forwarded command. Use `--` when the forwarded command needs the same flag names.';
+    static examples = [
+        '<%= config.bin %> <%= command.id %> build',
+        '<%= config.bin %> <%= command.id %> --env local pm list',
+        '<%= config.bin %> <%= command.id %> --env docker-local -- pm enable @nocobase/plugin-sample --yes',
+    ];
+    async run() {
+        const originalArgv = [...this.argv];
+        await this.parse({ strict: false, flags: {}, args: {} }, []);
+        this.argv = originalArgv;
+        let parsed;
+        try {
+            parsed = parseBridgeArgv(this.argv);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(message);
+        }
+        const { requestedEnv, yes, passthroughArgs } = parsed;
+        if (passthroughArgs.length === 0) {
+            this.error('Pass at least one v1 command to forward.');
+        }
+        const explicitEnvSelection = Boolean(requestedEnv && hasExplicitEnvSelection(this.argv));
+        if (explicitEnvSelection) {
+            const confirmed = await ensureCrossEnvConfirmed({
+                command: this,
+                requestedEnv,
+                yes,
+            });
+            if (!confirmed) {
+                return;
+            }
+        }
+        const runtime = await resolveManagedAppRuntime(requestedEnv);
+        if (!runtime) {
+            this.error(formatMissingManagedAppEnvMessage(requestedEnv));
+        }
+        const silentLike = hasSilentLikePassthrough(passthroughArgs);
+        const silentBridge = silentLike ? createSilentBridgeOptions() : undefined;
+        if (!silentLike) {
+            announceTargetEnv(runtime.envName);
+        }
+        if (runtime.kind === 'local') {
+            try {
+                await runLocalNocoBaseCommand(runtime, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'docker') {
+            try {
+                await runDockerNocoBaseCommand(runtime.containerName, passthroughArgs, silentBridge?.commandOptions);
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : String(error);
+                this.error(message);
+            }
+            finally {
+                silentBridge?.flush();
+            }
+            return;
+        }
+        if (runtime.kind === 'http') {
+            this.error(formatHttpEnvError(runtime.envName));
+        }
+        this.error(formatSshEnvError(runtime.envName));
+    }
+}

package/dist/lib/app-managed-resources.js

@@ -32,6 +32,18 @@ function localSourceLabel(source) {
 function trimValue(value) {
     return String(value ?? '').trim();
 }
+function pushOptionalEnvArg(args, key, value) {
+    if (typeof value === 'string') {
+        if (!value) {
+            return;
+        }
+        args.push('-e', `${key}=${value}`);
+        return;
+    }
+    if (typeof value === 'boolean') {
+        args.push('-e', `${key}=${String(value)}`);
+    }
+}
 function normalizeDockerPlatform(value) {
     const text = trimValue(value);
     if (!text || text === 'auto') {
@@ -109,6 +121,9 @@ export async function buildSavedDockerRunArgs(runtime) {
     const dbDatabase = trimValue(config.dbDatabase);
     const dbUser = trimValue(config.dbUser);
     const dbPassword = trimValue(config.dbPassword);
+    const dbSchema = trimValue(config.dbSchema);
+    const dbTablePrefix = trimValue(config.dbTablePrefix);
+    const dbUnderscored = typeof config.dbUnderscored === 'boolean' ? config.dbUnderscored : undefined;
     const dockerRegistry = trimValue(config.dockerRegistry) || DEFAULT_DOCKER_REGISTRY;
     const version = trimValue(config.downloadVersion) || DEFAULT_DOCKER_VERSION;
     const imageRef = resolveDockerImageRef(dockerRegistry, version, {
@@ -163,7 +178,11 @@ export async function buildSavedDockerRunArgs(runtime) {
     if (envFile) {
         args.push('--env-file', envFile);
     }
-    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`, imageRef);
+    args.push('-e', `APP_KEY=${appKey}`, '-e', `DB_DIALECT=${dbDialect}`, '-e', `DB_HOST=${dbHost}`, '-e', `DB_PORT=${dbPort}`, '-e', `DB_DATABASE=${dbDatabase}`, '-e', `DB_USER=${dbUser}`, '-e', `DB_PASSWORD=${dbPassword}`, '-e', `TZ=${timeZone}`, '-v', `${storagePath}:${DOCKER_APP_STORAGE_DESTINATION}`);
+    pushOptionalEnvArg(args, 'DB_SCHEMA', dbSchema || undefined);
+    pushOptionalEnvArg(args, 'DB_TABLE_PREFIX', dbTablePrefix || undefined);
+    pushOptionalEnvArg(args, 'DB_UNDERSCORED', dbUnderscored);
+    args.push(imageRef);
     return {
         appPort: appPort || undefined,
         storagePath,

package/dist/lib/app-runtime.js

@@ -119,8 +119,13 @@ export async function runLocalNocoBaseCommand(runtime, args, options) {
     const envVars = await buildRuntimeEnvVars(runtime);
     await runNocoBaseCommand(args, {
         cwd: runtime.projectRoot,
-        env: envVars,
+        env: {
+            ...envVars,
+            ...options?.env,
+        },
         stdio: options?.stdio,
+        onStdout: options?.onStdout,
+        onStderr: options?.onStderr,
     });
 }
 export async function dockerContainerExists(containerName) {
@@ -163,9 +168,13 @@ export async function stopDockerContainer(containerName, options) {
     });
     return 'stopped';
 }
-export async function runDockerNocoBaseCommand(containerName, args) {
-    await startDockerContainer(containerName);
-    await run('docker', ['exec', '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
+export async function runDockerNocoBaseCommand(containerName, args, options) {
+    await startDockerContainer(containerName, { stdio: options?.stdio });
+    const dockerEnvArgs = Object.entries(options?.env ?? {}).flatMap(([key, value]) => ['-e', `${key}=${value}`]);
+    await run('docker', ['exec', ...dockerEnvArgs, '-w', DOCKER_APP_WORKDIR, containerName, 'yarn', 'nocobase', ...args], {
         errorName: 'docker exec',
+        stdio: options?.stdio,
+        onStdout: options?.onStdout,
+        onStderr: options?.onStderr,
     });
 }

package/dist/lib/auth-store.js

@@ -8,7 +8,8 @@
  */
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
-import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath, } from './cli-home.js';
+import { resolveCliHomeDir, resolveConfiguredEnvPath, resolveEnvRelativePath } from './cli-home.js';
+import { normalizeCliLocale } from './cli-locale.js';
 import { cleanupCurrentSessionAfterEnvRemoval, resolveEffectiveCurrentEnv, setSessionCurrentEnv, } from './session-store.js';
 function normalizeStoredEnvKind(value) {
     const kind = String(value ?? '').trim();
@@ -24,13 +25,20 @@ function normalizeOptionalString(value) {
     const normalized = String(value ?? '').trim();
     return normalized || undefined;
 }
+function normalizeOptionalCliLocale(value) {
+    const normalized = normalizeOptionalString(value);
+    if (!normalized) {
+        return undefined;
+    }
+    return normalizeCliLocale(normalized);
+}
 export function readEnvApiBaseUrl(config) {
     if (!config) {
         return undefined;
     }
-    return (normalizeOptionalString(config.apiBaseUrl)
-        ?? normalizeOptionalString(config.baseUrl)
-        ?? normalizeOptionalString(config.apibaseUrl));
+    return (normalizeOptionalString(config.apiBaseUrl) ??
+        normalizeOptionalString(config.baseUrl) ??
+        normalizeOptionalString(config.apibaseUrl));
 }
 export function resolveEnvKind(config) {
     if (!config) {
@@ -70,9 +78,11 @@ function normalizeEnvConfigEntry(entry) {
 }
 function normalizeAuthConfig(config) {
     const settings = config.settings ?? {};
+    const locale = normalizeOptionalCliLocale(settings.locale);
     return {
         name: config.name || config.dockerResourcePrefix,
         settings: {
+            ...(locale ? { locale } : {}),
             ...(settings.license?.pkgUrl ? { license: { pkgUrl: normalizeOptionalString(settings.license.pkgUrl) } } : {}),
             ...(settings.docker?.network || settings.docker?.containerPrefix
                 ? {
@@ -84,8 +94,19 @@ function normalizeAuthConfig(config) {
                     },
                 }
                 : {}),
+            ...(settings.bin?.docker || settings.bin?.git || settings.bin?.yarn
+                ? {
+                    bin: {
+                        ...(settings.bin?.docker ? { docker: normalizeOptionalString(settings.bin.docker) } : {}),
+                        ...(settings.bin?.git ? { git: normalizeOptionalString(settings.bin.git) } : {}),
+                        ...(settings.bin?.yarn ? { yarn: normalizeOptionalString(settings.bin.yarn) } : {}),
+                    },
+                }
+                : {}),
         },
-        lastEnv: config.lastEnv || config.currentEnv || 'default',
+        lastEnv: config.lastEnv ||
+            config.currentEnv ||
+            'default',
         envs: Object.fromEntries(Object.entries(config.envs || {}).map(([envName, entry]) => [envName, normalizeEnvConfigEntry(entry) ?? {}])),
     };
 }
@@ -159,6 +180,9 @@ export class Env {
     get auth() {
         return this.config.auth;
     }
+    get authType() {
+        return resolveConfiguredAuthType(this.config);
+    }
     get runtime() {
         return this.config.runtime;
     }
@@ -210,16 +234,20 @@ export class Env {
         put('DB_DATABASE', this.config.dbDatabase);
         put('DB_USER', this.config.dbUser);
         put('DB_PASSWORD', this.config.dbPassword);
+        put('DB_SCHEMA', this.config.dbSchema);
+        put('DB_TABLE_PREFIX', this.config.dbTablePrefix);
+        put('DB_UNDERSCORED', this.config.dbUnderscored);
         return out;
     }
 }
 export async function getEnv(envName, options = {}) {
     const { config: snapshot, ...loadOptions } = options;
     const config = snapshot ?? (await loadAuthConfig(loadOptions));
-    const resolved = envName?.trim() || (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
-        scope: loadOptions.scope,
-        lastEnv: config.lastEnv,
-    }));
+    const resolved = envName?.trim() ||
+        (await resolveEffectiveCurrentEnv(Object.keys(config.envs).sort(), {
+            scope: loadOptions.scope,
+            lastEnv: config.lastEnv,
+        }));
     const envConfig = config.envs[resolved];
     if (!envConfig) {
         return undefined;
@@ -253,27 +281,41 @@ async function writeEnv(envName, updater, options = {}) {
     config.envs[envName] = updater(previous);
     await saveAuthConfig(config, options);
 }
+function normalizeConfiguredAuthType(value) {
+    return value === 'basic' || value === 'token' || value === 'oauth' ? value : undefined;
+}
+export function resolveConfiguredAuthType(config) {
+    return normalizeConfiguredAuthType(config?.authType) ?? normalizeConfiguredAuthType(config?.auth?.type);
+}
 export async function upsertEnv(envName, config, options = {}) {
     await writeEnv(envName, (previous) => {
-        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, ...rest } = config;
+        const { apiBaseUrl: _apiBaseUrl, baseUrl: _baseUrl, apibaseUrl: _legacyApiBaseUrl, accessToken, authType, authUsername, ...rest } = config;
         const nextApiBaseUrl = readEnvApiBaseUrl(config);
         const previousApiBaseUrl = readEnvApiBaseUrl(previous);
         const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
+        const previousAuthType = resolveConfiguredAuthType(previous);
+        const requestedAuthType = normalizeConfiguredAuthType(authType);
+        const nextAuthType = requestedAuthType ?? (accessToken ? 'token' : previousAuthType);
+        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(authUsername) ?? previous?.authUsername : undefined;
         const nextAuth = accessToken
             ? {
                 type: 'token',
                 accessToken,
             }
-            : baseUrlChanged || previous?.auth?.type === 'token'
-                ? undefined
-                : previous?.auth;
+            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
+                ? previous.auth
+                : undefined;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        const authTypeChanged = previousAuthType !== nextAuthType;
+        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
         return {
             ...previous,
             apiBaseUrl: nextApiBaseUrl,
+            authType: nextAuthType,
+            authUsername: nextAuthUsername,
             auth: nextAuth,
             ...rest,
-            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
         };
     }, options);
 }
@@ -282,26 +324,35 @@ export async function updateEnvConnection(envName, updates, options = {}) {
         const nextApiBaseUrl = readEnvApiBaseUrl(updates) ?? readEnvApiBaseUrl(previous);
         const previousApiBaseUrl = readEnvApiBaseUrl(previous);
         const baseUrlChanged = previousApiBaseUrl !== nextApiBaseUrl;
+        const previousAuthType = resolveConfiguredAuthType(previous);
+        const requestedAuthType = normalizeConfiguredAuthType(updates.authType);
+        const nextAuthType = requestedAuthType ?? (updates.accessToken ? 'token' : previousAuthType);
+        const nextAuthUsername = nextAuthType === 'basic' ? normalizeOptionalString(updates.authUsername) ?? previous?.authUsername : undefined;
         const nextAuth = updates.accessToken
             ? {
                 type: 'token',
                 accessToken: updates.accessToken,
             }
-            : baseUrlChanged || previous?.auth?.type === 'token'
-                ? undefined
-                : previous?.auth;
+            : nextAuthType === 'oauth' && !baseUrlChanged && previous?.auth?.type === 'oauth'
+                ? previous.auth
+                : undefined;
         const authChanged = !areAuthConfigsEquivalent(previous?.auth, nextAuth);
+        const authTypeChanged = previousAuthType !== nextAuthType;
+        const authUsernameChanged = previous?.authUsername !== nextAuthUsername;
         return {
             ...previous,
             ...(nextApiBaseUrl !== undefined ? { apiBaseUrl: nextApiBaseUrl } : {}),
+            authType: nextAuthType,
+            authUsername: nextAuthUsername,
             auth: nextAuth,
-            runtime: baseUrlChanged || authChanged ? undefined : previous?.runtime,
+            runtime: baseUrlChanged || authChanged || authTypeChanged || authUsernameChanged ? undefined : previous?.runtime,
         };
     }, options);
 }
 export async function setEnvOauthSession(envName, auth, options = {}) {
     await writeEnv(envName, (previous) => ({
         ...previous,
+        authType: 'oauth',
         auth,
         runtime: options.preserveRuntime ? previous?.runtime : undefined,
     }), options);