@nocobase/cli 2.2.0-beta.8 → 2.2.0-test.15

package/dist/lib/portal-template.js

@@ -0,0 +1,190 @@
+/**
+ * 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 { cp, mkdir, mkdtemp, rm, stat } from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { buildPortalCommandEnv } from './portal-command-env.js';
+import { resolvePortalTemplate } from './portal-create.js';
+import { run } from './run-npm.js';
+const DEFAULT_PORTAL_APP_NAME = 'main';
+const DEFAULT_PORTAL_NAME = 'admin';
+const PORTAL_CLIENT_PREFIX = 'x';
+function trimValue(value) {
+    return String(value ?? '').trim();
+}
+function normalizePortalName(value) {
+    const segment = String(value || '')
+        .trim()
+        .replace(/^\/+|\/+$/g, '');
+    return segment || DEFAULT_PORTAL_NAME;
+}
+function normalizePortalAppName(value) {
+    const segment = String(value || '')
+        .trim()
+        .replace(/^\/+|\/+$/g, '');
+    return segment || DEFAULT_PORTAL_APP_NAME;
+}
+function validatePortalSegment(kind, value) {
+    if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(value)) {
+        throw new Error(`Invalid ${kind} "${value}". Use letters, numbers, underscores, or hyphens, and start with a letter or number.`);
+    }
+}
+async function pathExists(filePath) {
+    try {
+        await stat(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveLocalTemplatePath(templateSource) {
+    if (templateSource.startsWith('file://')) {
+        return fileURLToPath(templateSource);
+    }
+    return templateSource;
+}
+function isGitTemplateSource(templateSource) {
+    return (templateSource.startsWith('git@') ||
+        templateSource.startsWith('git+') ||
+        /^https?:\/\//i.test(templateSource) ||
+        templateSource.endsWith('.git'));
+}
+async function getLocalTemplateDir(templateSource) {
+    let localPath;
+    try {
+        localPath = resolveLocalTemplatePath(templateSource);
+    }
+    catch {
+        return undefined;
+    }
+    let result;
+    try {
+        result = await stat(localPath);
+    }
+    catch {
+        return undefined;
+    }
+    if (!result.isDirectory()) {
+        throw new Error(`Portal template "${templateSource}" is invalid: expected a directory.`);
+    }
+    return localPath;
+}
+async function resolveInitialPortalTemplate(params) {
+    const localTemplateDir = await getLocalTemplateDir(params.templateSource);
+    if (localTemplateDir) {
+        return {
+            dir: localTemplateDir,
+            source: params.templateSource,
+            type: 'local',
+        };
+    }
+    if (!isGitTemplateSource(params.templateSource)) {
+        return resolvePortalTemplate(params.templateSource, {
+            npmRegistry: params.npmRegistry,
+            runCommand: params.runCommand,
+        });
+    }
+    await params.runCommand('git', ['clone', '--depth', '1', params.templateSource, params.tempDir], {
+        errorName: 'git clone',
+        stdio: params.verbose ? 'inherit' : 'ignore',
+    });
+    return {
+        dir: params.tempDir,
+        source: params.templateSource,
+        type: 'local',
+    };
+}
+async function copyTemplate(sourceDir, targetDir) {
+    await mkdir(path.dirname(targetDir), { recursive: true });
+    await cp(sourceDir, targetDir, {
+        recursive: true,
+        filter: (source) => !source.split(path.sep).includes('.git'),
+    });
+}
+async function buildPortalHtml(params) {
+    const stdio = params.verbose ? 'inherit' : 'ignore';
+    await params.runCommand('yarn', ['build:html'], {
+        cwd: params.portalDir,
+        env: buildPortalCommandEnv({
+            NOCOBASE_API_URL: '/api',
+            NOCOBASE_PORTAL_BASE: `/${PORTAL_CLIENT_PREFIX}/${params.portalName}/`,
+        }),
+        envMode: 'replace',
+        errorName: 'yarn build:html',
+        stdio,
+    });
+}
+export async function prepareInitialPortalTemplate(options) {
+    const developmentMode = trimValue(options.developmentMode);
+    if (developmentMode !== 'vibe-coding') {
+        return { prepared: false, skippedReason: 'no-code' };
+    }
+    const storagePath = trimValue(options.storagePath);
+    if (!storagePath) {
+        throw new Error('Cannot prepare an initial Portal template without a storage path.');
+    }
+    const templateUrl = trimValue(options.portalTemplate);
+    if (!templateUrl) {
+        throw new Error('Initial Portal template is required when development mode is "vibe-coding".');
+    }
+    const appName = normalizePortalAppName(options.appName);
+    const portalName = normalizePortalName(options.portalName);
+    validatePortalSegment('portal app name', appName);
+    validatePortalSegment('Portal name', portalName);
+    const portalDir = path.join(storagePath, 'portals', appName, portalName);
+    if (await pathExists(portalDir)) {
+        if (await pathExists(path.join(portalDir, 'dist', 'index.html'))) {
+            return { prepared: false, skippedReason: 'already-prepared' };
+        }
+        await rm(portalDir, { recursive: true, force: true });
+    }
+    options.onStartTask?.(`Preparing Portal "${portalName}" from template...`);
+    const runCommand = options.runCommand ?? run;
+    const tempDir = await mkdtemp(path.join(os.tmpdir(), 'nocobase-portal-template-'));
+    let cleanupPortalDir = false;
+    let template;
+    try {
+        template = await resolveInitialPortalTemplate({
+            templateSource: templateUrl,
+            tempDir,
+            npmRegistry: options.npmRegistry,
+            verbose: options.verbose,
+            runCommand,
+        });
+        const templateDir = template.dir;
+        if (!(await pathExists(path.join(templateDir, 'package.json')))) {
+            throw new Error(`Portal template "${templateUrl}" is invalid: package.json is missing.`);
+        }
+        cleanupPortalDir = true;
+        await copyTemplate(templateDir, portalDir);
+        await rm(path.join(portalDir, 'node_modules'), { recursive: true, force: true });
+        await buildPortalHtml({
+            portalDir,
+            portalName,
+            verbose: options.verbose,
+            runCommand,
+        });
+        cleanupPortalDir = false;
+        options.onSucceedTask?.(`Portal "${portalName}" is ready.`);
+        return { prepared: true };
+    }
+    catch (error) {
+        if (cleanupPortalDir) {
+            await rm(portalDir, { recursive: true, force: true });
+        }
+        options.onFailTask?.(`Failed to prepare Portal "${portalName}".`);
+        throw error;
+    }
+    finally {
+        await rm(tempDir, { recursive: true, force: true });
+        await template?.cleanup?.();
+    }
+}

package/dist/lib/prompt-catalog-terminal.js

@@ -11,6 +11,17 @@ import { exit, stdin as stdinStream, stdout as stdoutStream } from 'node:process
 import { createCliTranslate } from "./cli-locale.js";
 import { confirm, select, input, password } from "./inquirer.js";
 import { createPromptCatalogHooks, hasIvKey, isBlankText, isPromptBlockSkipped, mergedBoolean, mergedInteger, mergedPassword, mergedSelect, mergedText, resolvePromptCatalogLocale, resolvePromptText, runPromptFieldValidate, selectOptionValues, tryApplyPreset, } from "./prompt-catalog-core.js";
+function buildPromptComputationSeed(catalog, initialValues) {
+    const catalogKeys = new Set(Object.keys(catalog));
+    const seed = {};
+    for (const [key, value] of Object.entries(initialValues)) {
+        if (catalogKeys.has(key) || value === undefined || value === null) {
+            continue;
+        }
+        seed[key] = value;
+    }
+    return seed;
+}
 function adaptInquirerValidate(validate) {
     if (!validate) {
         return undefined;
@@ -113,14 +124,16 @@ export async function runPromptCatalog(catalog, options = {}) {
     const hooks = createTerminalHooks(locale, options.hooks);
     const interactive = Boolean(stdinStream.isTTY && stdoutStream.isTTY && !options.yes);
     const preset = options.values ?? {};
+    const computationSeed = buildPromptComputationSeed(catalog, resolveIv);
     const out = {};
     const renderer = createInquirerRenderer();
     for (const [key, def] of Object.entries(catalog)) {
-        if (isPromptBlockSkipped(def, out)) {
+        const valuesSoFar = { ...computationSeed, ...out };
+        if (isPromptBlockSkipped(def, valuesSoFar)) {
             continue;
         }
         if (tryApplyPreset(key, def, preset, out, hooks, locale)) {
-            const errV = await runPromptFieldValidate(def, out[key], out);
+            const errV = await runPromptFieldValidate(def, out[key], { ...computationSeed, ...out });
             if (errV) {
                 hooks.onMissingNonInteractive(errV);
             }
@@ -135,7 +148,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             continue;
         }
         if (def.type === 'run') {
-            await def.run(out, options.command);
+            await def.run({ ...computationSeed, ...out }, options.command);
             continue;
         }
         if (def.type === 'text') {
@@ -144,18 +157,18 @@ export async function runPromptCatalog(catalog, options = {}) {
                 ? resolvePromptText(def.placeholder, locale)
                 : undefined;
             if (!interactive) {
-                const merged = mergedText(key, def, resolveIv, useYesInitial, out);
+                const merged = mergedText(key, def, resolveIv, useYesInitial, valuesSoFar);
                 if (def.required && isBlankText(merged)) {
                     hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.textRequired', { key }));
                 }
                 out[key] = merged;
-                const errT = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errT = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errT) {
                     hooks.onMissingNonInteractive(errT);
                 }
                 continue;
             }
-            const merged = mergedText(key, def, promptIv, false, out);
+            const merged = mergedText(key, def, promptIv, false, valuesSoFar);
             const raw = await callPrompt(() => renderer.text({
                 message,
                 initialValue: merged,
@@ -168,7 +181,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const currentValue = typeof value === 'string' ? value : String(value ?? '');
-                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    const result = runPromptFieldValidate(def, currentValue, { ...computationSeed, ...out, [key]: currentValue });
                     return result;
                 },
             }), renderer, hooks);
@@ -180,7 +193,7 @@ export async function runPromptCatalog(catalog, options = {}) {
             if (!interactive) {
                 const b = mergedBoolean(key, def, resolveIv, useYesInitial);
                 out[key] = b;
-                const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                const errB = await runPromptFieldValidate(def, b, { ...computationSeed, ...out, [key]: b });
                 if (errB) {
                     hooks.onMissingNonInteractive(errB);
                 }
@@ -191,7 +204,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                 for (;;) {
                     const raw = await callPrompt(() => renderer.confirm({ message, initialValue: merged }), renderer, hooks);
                     const b = Boolean(raw);
-                    const errB = await runPromptFieldValidate(def, b, { ...out, [key]: b });
+                    const errB = await runPromptFieldValidate(def, b, { ...computationSeed, ...out, [key]: b });
                     if (errB) {
                         renderer.error(errB);
                         continue;
@@ -224,7 +237,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         : t('promptCatalog.nonInteractive.selectMissingDefault', { key }));
                 }
                 out[key] = merged;
-                const errS = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errS = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errS) {
                     hooks.onMissingNonInteractive(errS);
                 }
@@ -248,7 +261,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         initialValue: uiInitial,
                     }), renderer, hooks);
                     const picked = raw;
-                    const errS = await runPromptFieldValidate(def, picked, { ...out, [key]: picked });
+                    const errS = await runPromptFieldValidate(def, picked, { ...computationSeed, ...out, [key]: picked });
                     if (errS) {
                         renderer.error(errS);
                         continue;
@@ -269,13 +282,13 @@ export async function runPromptCatalog(catalog, options = {}) {
         if (def.type === 'password') {
             const message = resolvePromptText(def.message, locale, key);
             if (!interactive) {
-                const merged = mergedPassword(key, def, resolveIv, useYesInitial);
+                const merged = mergedPassword(key, def, resolveIv, useYesInitial, valuesSoFar);
                 if (merged === undefined) {
                     if (def.required) {
                         hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequired', { key }));
                     }
                     out[key] = '';
-                    const errPE = await runPromptFieldValidate(def, '', { ...out, [key]: '' });
+                    const errPE = await runPromptFieldValidate(def, '', { ...computationSeed, ...out, [key]: '' });
                     if (errPE) {
                         hooks.onMissingNonInteractive(errPE);
                     }
@@ -285,7 +298,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                     hooks.onMissingNonInteractive(t('promptCatalog.nonInteractive.passwordRequiredNonEmpty', { key }));
                 }
                 out[key] = merged;
-                const errP = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errP = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errP) {
                     hooks.onMissingNonInteractive(errP);
                 }
@@ -302,7 +315,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const currentValue = typeof value === 'string' ? value : String(value ?? '');
-                    const result = runPromptFieldValidate(def, currentValue, { ...out, [key]: currentValue });
+                    const result = runPromptFieldValidate(def, currentValue, { ...computationSeed, ...out, [key]: currentValue });
                     return result;
                 },
             }), renderer, hooks);
@@ -322,14 +335,14 @@ export async function runPromptCatalog(catalog, options = {}) {
                     }
                     const z = def.initialValue ?? 0;
                     out[key] = z;
-                    const errI = await runPromptFieldValidate(def, z, { ...out, [key]: z });
+                    const errI = await runPromptFieldValidate(def, z, { ...computationSeed, ...out, [key]: z });
                     if (errI) {
                         hooks.onMissingNonInteractive(errI);
                     }
                     continue;
                 }
                 out[key] = merged;
-                const errI2 = await runPromptFieldValidate(def, merged, { ...out, [key]: merged });
+                const errI2 = await runPromptFieldValidate(def, merged, { ...computationSeed, ...out, [key]: merged });
                 if (errI2) {
                     hooks.onMissingNonInteractive(errI2);
                 }
@@ -349,7 +362,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         }
                         if (def.validate) {
                             const z = def.initialValue ?? 0;
-                            return runPromptFieldValidate(def, z, { ...out, [key]: z });
+                            return runPromptFieldValidate(def, z, { ...computationSeed, ...out, [key]: z });
                         }
                         return undefined;
                     }
@@ -360,7 +373,7 @@ export async function runPromptCatalog(catalog, options = {}) {
                         return undefined;
                     }
                     const n = Number.parseInt(trimmed, 10);
-                    return runPromptFieldValidate(def, n, { ...out, [key]: n });
+                    return runPromptFieldValidate(def, n, { ...computationSeed, ...out, [key]: n });
                 },
             }), renderer, hooks);
             if (typeof raw === 'string' && raw.trim() === '' && !def.required) {

package/dist/lib/prompt-web-ui.js

@@ -48,13 +48,24 @@ function isInputBlock(def) {
         def.type === 'password' ||
         def.type === 'integer');
 }
+function buildPromptComputationSeed(catalog, userPreset) {
+    const catalogKeys = new Set(Object.keys(catalog));
+    const seed = {};
+    for (const [key, value] of Object.entries(userPreset)) {
+        if (catalogKeys.has(key) || value === undefined || value === null) {
+            continue;
+        }
+        seed[key] = value;
+    }
+    return seed;
+}
 /**
  * Merges CLI/env **`userPreset`** with catalog block defaults, in the same key order and with the
  * same `hidden` / `run` semantics as {@link isPromptBlockSkipped}, so the web form can prefill
  * and reflow `hidden` fields (e.g. `integer` when `select` changes).
  */
 export function buildWebFormValuesFromCatalog(catalog, userPreset = {}) {
-    const out = {};
+    const out = buildPromptComputationSeed(catalog, userPreset);
     for (const [key, def] of Object.entries(catalog)) {
         if (def.type === 'intro' || def.type === 'outro') {
             continue;
@@ -109,7 +120,7 @@ function defaultValueForInput(key, def, out) {
  * from current raw form data (e.g. after changing `select`). Matches how {@link isPromptBlockSkipped} uses `out` while iterating the catalog.
  */
 export function reflowWebFormState(catalog, raw, userSeed = {}) {
-    const out = {};
+    const out = buildPromptComputationSeed(catalog, userSeed);
     const show = {};
     for (const [key, def] of Object.entries(catalog)) {
         if (def.type === 'intro' || def.type === 'outro') {

package/dist/lib/proxy-caddy.js

@@ -9,14 +9,17 @@
 import { mkdir, readFile, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { dockerContainerExists, dockerContainerIsRunning, startDockerContainer, stopDockerContainer, } from './app-runtime.js';
+import { loadAuthConfig } from './auth-store.js';
 import { CADDY_PROXY_DRIVER_OPTIONS, DEFAULT_CADDY_PROXY_DRIVER, getCliConfigValue, normalizeCaddyProxyDriver, resolveDockerContainerPrefix, setCliConfigValue, } from './cli-config.js';
 import { resolveCliHomeRoot } from './cli-home.js';
-import { applyEnvProxyAppEntryOptions, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
-import { run } from './run-npm.js';
+import { applyEnvProxyAppEntryOptions, buildManualEnvProxyCaddyBundle, buildEnvProxyCaddyBundle, buildEnvProxyMainConfig, mapProxyPathFromCliRoot, resolveEnvProxyMainOutputPath, } from './env-proxy.js';
+import { normalizeEnvProxyConfig } from './env-proxy-config.js';
+import { commandOutput, run } from './run-npm.js';
 const DOCKER_CADDY_PROXY_CONTAINER_SUFFIX = 'caddy-proxy';
 const DOCKER_CADDY_PROXY_IMAGE = 'caddy:latest';
 const DOCKER_CADDY_PROXY_RUNTIME_ROOT = '/apps';
 const DOCKER_CADDY_PROXY_CONF_DESTINATION = '/etc/caddy/Caddyfile';
+const DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS = [80, 443];
 async function readOptionalTextFile(filePath) {
     try {
         return await readFile(filePath, 'utf8');
@@ -62,8 +65,9 @@ export async function resolveCaddyProxyRuntimeContext(options) {
         upstreamHost: resolveCaddyProxyUpstreamHost(driver),
     };
 }
-export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext) {
+export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeContext, options) {
     const bundle = await buildEnvProxyCaddyBundle(runtime, {
+        cdnBaseUrl: options?.cdnBaseUrl,
         runtimeCliRoot: runtimeContext.runtimeCliRoot,
         upstreamHost: runtimeContext.upstreamHost,
     });
@@ -82,6 +86,27 @@ export async function writeCaddyProxyBundle(runtime, appEntryOptions, runtimeCon
         status,
     };
 }
+export async function writeManualCaddyProxyBundle(input, appEntryOptions, runtimeContext, options) {
+    const bundle = await buildManualEnvProxyCaddyBundle(input, {
+        cdnBaseUrl: options?.cdnBaseUrl,
+        runtimeCliRoot: runtimeContext.runtimeCliRoot,
+        upstreamHost: input.upstreamHost || runtimeContext.upstreamHost,
+    });
+    const currentAppConfigContent = await readOptionalTextFile(bundle.appConfigPath);
+    const nextAppConfigContent = applyEnvProxyAppEntryOptions(bundle.appConfigContent, 'caddy', appEntryOptions);
+    const status = currentAppConfigContent ? 'updated' : 'created';
+    await Promise.all([mkdir(bundle.entryDir, { recursive: true }), mkdir(bundle.publicDir, { recursive: true })]);
+    await Promise.all([
+        writeFile(bundle.appConfigPath, nextAppConfigContent, 'utf8'),
+        writeFile(bundle.indexV1Path, bundle.indexV1Content, 'utf8'),
+        writeFile(bundle.indexV2Path, bundle.indexV2Content, 'utf8'),
+        writeFile(bundle.mainConfigPath, bundle.mainConfigContent, 'utf8'),
+    ]);
+    return {
+        bundle,
+        status,
+    };
+}
 function resolveLocalCaddyPidFilePath() {
     return path.join(path.dirname(resolveEnvProxyMainOutputPath({ provider: 'caddy' })), 'caddy.pid');
 }
@@ -149,11 +174,16 @@ async function reloadLocalCaddyProxy(runtimeContext) {
 }
 async function ensureDockerCaddyProxyContainer(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
+    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const publishedPorts = await resolveDockerCaddyPublishedPorts();
     if (await dockerContainerExists(containerName)) {
-        return;
+        if (await dockerCaddyProxyContainerMatchesPublishedPorts(containerName, publishedPorts)) {
+            return;
+        }
+        await removeDockerCaddyProxyContainer(containerName);
     }
     const hostCliRoot = String(process.env.NB_CLI_ROOT ?? resolveCliHomeRoot()).trim() || resolveCliHomeRoot();
-    const mainConfigPath = await ensureCaddyProxyMainConfig(runtimeContext);
+    const dockerPortArgs = publishedPorts.flatMap((port) => ['-p', `${port}:${port}`]);
     await run('docker', [
         'run',
         '-d',
@@ -161,8 +191,7 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         containerName,
         '--add-host',
         'host.docker.internal:host-gateway',
-        '-p',
-        '80:80',
+        ...dockerPortArgs,
         '-v',
         `${hostCliRoot}:${DOCKER_CADDY_PROXY_RUNTIME_ROOT}`,
         '-v',
@@ -173,14 +202,53 @@ async function ensureDockerCaddyProxyContainer(runtimeContext) {
         stdio: 'ignore',
     });
 }
+async function resolveDockerCaddyPublishedPorts() {
+    const config = await loadAuthConfig();
+    const ports = new Set(DEFAULT_DOCKER_CADDY_PROXY_PUBLISHED_PORTS);
+    for (const envConfig of Object.values(config.envs)) {
+        const port = normalizeEnvProxyConfig(envConfig.proxy)?.port;
+        if (port !== undefined) {
+            ports.add(port);
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function readDockerCaddyPublishedPorts(containerName) {
+    const output = await commandOutput('docker', ['inspect', '--format', '{{json .HostConfig.PortBindings}}', containerName], { errorName: 'docker inspect' });
+    const parsed = JSON.parse(output.trim() || '{}');
+    const ports = new Set();
+    for (const bindings of Object.values(parsed)) {
+        if (!Array.isArray(bindings)) {
+            continue;
+        }
+        for (const binding of bindings) {
+            const port = Number.parseInt(String(binding?.HostPort ?? '').trim(), 10);
+            if (Number.isInteger(port) && port > 0) {
+                ports.add(port);
+            }
+        }
+    }
+    return Array.from(ports).sort((left, right) => left - right);
+}
+async function dockerCaddyProxyContainerMatchesPublishedPorts(containerName, expectedPorts) {
+    const currentPorts = await readDockerCaddyPublishedPorts(containerName);
+    return currentPorts.length === expectedPorts.length && currentPorts.every((port, index) => port === expectedPorts[index]);
+}
+async function removeDockerCaddyProxyContainer(containerName) {
+    await run('docker', ['rm', '-f', containerName], {
+        errorName: 'docker rm',
+        stdio: 'ignore',
+    });
+}
 async function startDockerCaddyProxy(runtimeContext) {
     const containerName = await resolveCaddyProxyContainerName();
     await ensureCaddyProxyMainConfig(runtimeContext);
-    if (await dockerContainerExists(containerName)) {
+    const existedBeforeEnsure = await dockerContainerExists(containerName);
+    await ensureDockerCaddyProxyContainer(runtimeContext);
+    if (existedBeforeEnsure && (await dockerContainerExists(containerName))) {
         const state = await startDockerContainer(containerName, { stdio: 'ignore' });
         return state === 'already-running' ? 'already-running' : 'started';
     }
-    await ensureDockerCaddyProxyContainer(runtimeContext);
     return 'started';
 }
 async function stopDockerCaddyProxy() {