@nocobase/cli 2.2.0-alpha.2 → 2.2.0-alpha.4

package/assets/env-proxy/nginx/app.conf.tpl

@@ -0,0 +1,23 @@
+# Rendered by `nb env proxy`.
+# Context:
+# publicBasePath={{publicBasePath}}
+# apiBasePath={{apiBasePath}}
+# wsPath={{wsPath}}
+# v2PublicPath={{v2PublicPath}}
+# backendUrl={{backendUrl}}
+# snippetsDir={{snippetsDir}}
+# uploadsDir={{uploadsDir}}
+# distRootDir={{distRootDir}}
+# entryDir={{entryDir}}
+# publicDir={{publicDir}}
+
+server {
+    listen 80;
+    server_name _;
+
+    # Add custom directives or locations above the managed block as needed.
+
+{{managedConfigBlock}}
+
+    # Add custom directives or locations below the managed block as needed.
+}

package/assets/env-proxy/nginx/nocobase.conf.tpl

@@ -0,0 +1,5 @@
+# Managed by `nb env proxy`. Changes will be overwritten.
+
+include {{snippetsDir}}/log-format-http.conf;
+include {{snippetsDir}}/maps-http.conf;
+include {{appConfigIncludePath}};

package/assets/env-proxy/nginx/snippets/dist-location.conf

@@ -0,0 +1,5 @@
+expires 365d;
+add_header Cache-Control "public" always;
+
+access_log off;
+autoindex off;

package/assets/env-proxy/nginx/snippets/gzip.conf

@@ -0,0 +1,17 @@
+gzip on;
+gzip_types
+    text/plain
+    text/css
+    text/xml
+    text/markdown
+    text/javascript
+    application/javascript
+    application/json
+    application/manifest+json
+    application/atom+xml
+    application/rss+xml
+    application/xml
+    application/xml+rss
+    application/xhtml+xml
+    application/wasm
+    image/svg+xml;

package/assets/env-proxy/nginx/snippets/log-format-http.conf

@@ -0,0 +1,13 @@
+log_format apm '"$time_local" client=$remote_addr '
+               'method=$request_method request="$request" '
+               'request_length=$request_length '
+               'status=$status bytes_sent=$bytes_sent '
+               'body_bytes_sent=$body_bytes_sent '
+               'referer=$http_referer '
+               'user_agent="$http_user_agent" '
+               'upstream_addr=$upstream_addr '
+               'upstream_status=$upstream_status '
+               'request_time=$request_time '
+               'upstream_response_time=$upstream_response_time '
+               'upstream_connect_time=$upstream_connect_time '
+               'upstream_header_time=$upstream_header_time';

package/assets/env-proxy/nginx/snippets/maps-http.conf

@@ -0,0 +1,14 @@
+map $http_upgrade $connection_upgrade {
+    default upgrade;
+    ""      close;
+}
+
+map $http_x_forwarded_proto $upstream_x_forwarded_proto {
+    default $http_x_forwarded_proto;
+    ""      $scheme;
+}
+
+map $http_host $final_host {
+    default $http_host;
+    ""      $host;
+}

package/assets/env-proxy/nginx/snippets/mime-types.conf

@@ -0,0 +1,98 @@
+types {
+    text/html                                        html htm shtml;
+    text/css                                         css;
+    text/xml                                         xml;
+    image/gif                                        gif;
+    image/jpeg                                       jpeg jpg;
+    application/javascript                           js mjs;
+    application/atom+xml                             atom;
+    application/rss+xml                              rss;
+
+    text/mathml                                      mml;
+    text/plain                                       txt;
+    text/vnd.sun.j2me.app-descriptor                 jad;
+    text/vnd.wap.wml                                 wml;
+    text/x-component                                 htc;
+
+    image/avif                                       avif;
+    image/png                                        png;
+    image/svg+xml                                    svg svgz;
+    image/tiff                                       tif tiff;
+    image/vnd.wap.wbmp                               wbmp;
+    image/webp                                       webp;
+    image/x-icon                                     ico;
+    image/x-jng                                      jng;
+    image/x-ms-bmp                                   bmp;
+
+    font/woff                                        woff;
+    font/woff2                                       woff2;
+
+    application/java-archive                         jar war ear;
+    application/json                                 json;
+    application/mac-binhex40                         hqx;
+    application/msword                               doc;
+    application/pdf                                  pdf;
+    application/postscript                           ps eps ai;
+    application/rtf                                  rtf;
+    application/vnd.apple.mpegurl                    m3u8;
+    application/vnd.google-earth.kml+xml             kml;
+    application/vnd.google-earth.kmz                 kmz;
+    application/vnd.ms-excel                         xls;
+    application/vnd.ms-fontobject                    eot;
+    application/vnd.ms-powerpoint                    ppt;
+    application/vnd.oasis.opendocument.graphics      odg;
+    application/vnd.oasis.opendocument.presentation  odp;
+    application/vnd.oasis.opendocument.spreadsheet   ods;
+    application/vnd.oasis.opendocument.text          odt;
+    application/vnd.openxmlformats-officedocument.presentationml.presentation
+                                                     pptx;
+    application/vnd.openxmlformats-officedocument.spreadsheetml.sheet
+                                                     xlsx;
+    application/vnd.openxmlformats-officedocument.wordprocessingml.document
+                                                     docx;
+    application/vnd.wap.wmlc                         wmlc;
+    application/wasm                                 wasm;
+    application/x-7z-compressed                      7z;
+    application/x-cocoa                              cco;
+    application/x-java-archive-diff                  jardiff;
+    application/x-java-jnlp-file                     jnlp;
+    application/x-makeself                           run;
+    application/x-perl                               pl pm;
+    application/x-pilot                              prc pdb;
+    application/x-rar-compressed                     rar;
+    application/x-redhat-package-manager             rpm;
+    application/x-sea                                sea;
+    application/x-shockwave-flash                    swf;
+    application/x-stuffit                            sit;
+    application/x-tcl                                tcl tk;
+    application/x-x509-ca-cert                       der pem crt;
+    application/x-xpinstall                          xpi;
+    application/xhtml+xml                            xhtml;
+    application/xspf+xml                             xspf;
+    application/zip                                  zip;
+
+    application/octet-stream                         bin exe dll;
+    application/octet-stream                         deb;
+    application/octet-stream                         dmg;
+    application/octet-stream                         iso img;
+    application/octet-stream                         msi msp msm;
+
+    audio/midi                                       mid midi kar;
+    audio/mpeg                                       mp3;
+    audio/ogg                                        ogg;
+    audio/x-m4a                                      m4a;
+    audio/x-realaudio                                ra;
+
+    video/3gpp                                       3gpp 3gp;
+    video/mp2t                                       ts;
+    video/mp4                                        mp4;
+    video/mpeg                                       mpeg mpg;
+    video/quicktime                                  mov;
+    video/webm                                       webm;
+    video/x-flv                                      flv;
+    video/x-m4v                                      m4v;
+    video/x-mng                                      mng;
+    video/x-ms-asf                                   asx asf;
+    video/x-ms-wmv                                   wmv;
+    video/x-msvideo                                  avi;
+}

package/assets/env-proxy/nginx/snippets/proxy-location.conf

@@ -0,0 +1,17 @@
+proxy_http_version 1.1;
+
+proxy_set_header Upgrade $http_upgrade;
+proxy_set_header Connection $connection_upgrade;
+proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+proxy_set_header X-Forwarded-Proto $upstream_x_forwarded_proto;
+proxy_set_header Host $final_host;
+proxy_set_header Referer $http_referer;
+proxy_set_header User-Agent $http_user_agent;
+
+add_header Cache-Control "no-cache, no-store" always;
+proxy_cache_bypass $http_upgrade;
+
+proxy_connect_timeout 600;
+proxy_send_timeout 600;
+proxy_read_timeout 600;
+send_timeout 600;

package/assets/env-proxy/nginx/snippets/spa-location.conf

@@ -0,0 +1,6 @@
+add_header Cache-Control "no-store, no-cache, must-revalidate" always;
+add_header X-Robots-Tag "noindex, nofollow" always;
+
+if_modified_since off;
+expires off;
+etag off;

package/assets/env-proxy/nginx/snippets/uploads-location.conf

@@ -0,0 +1,21 @@
+add_header Cache-Control "public" always;
+add_header X-Content-Type-Options "nosniff" always;
+
+access_log off;
+autoindex off;
+
+# Force potentially renderable uploaded files to download.
+location ~* \.(?:htm|html|svg|svgz|xhtml)$ {
+    add_header Cache-Control "public" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Content-Disposition "attachment" always;
+}
+
+# Let Markdown files render as plain Markdown text.
+location ~* \.md$ {
+    default_type text/markdown;
+
+    add_header Cache-Control "public" always;
+    add_header X-Content-Type-Options "nosniff" always;
+    add_header Content-Disposition "inline" always;
+}

package/dist/commands/install.js

@@ -1468,8 +1468,6 @@ export default class Install extends Command {
                 '-d',
                 '--name',
                 containerName,
-                '--restart',
-                'always',
                 '--network',
                 networkName,
                 '-e',
@@ -1512,8 +1510,6 @@ export default class Install extends Command {
                 '-d',
                 '--name',
                 containerName,
-                '--restart',
-                'always',
                 '--network',
                 networkName,
                 '-e',
@@ -1558,8 +1554,6 @@ export default class Install extends Command {
                 '-d',
                 '--name',
                 containerName,
-                '--restart',
-                'always',
                 '--network',
                 networkName,
                 '-e',
@@ -1604,8 +1598,6 @@ export default class Install extends Command {
                 '-d',
                 '--name',
                 containerName,
-                '--restart',
-                'always',
                 '--network',
                 networkName,
                 '--platform',
@@ -1805,8 +1797,6 @@ export default class Install extends Command {
             '-d',
             '--name',
             containerName,
-            '--restart',
-            'always',
             '--network',
             params.networkName,
             '-p',

package/dist/commands/proxy/caddy/generate.js

@@ -8,20 +8,49 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getCaddyProxyDriver, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
+import { getCaddyProxyDriver, writeManualCaddyProxyBundle, writeCaddyProxyBundle, resolveCaddyProxyRuntimeContext, } from '../../../lib/proxy-caddy.js';
 import { normalizeProxyListenPort } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyCaddyGenerate extends Command {
     static summary = 'Generate caddy proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy caddy generate --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy caddy generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy caddy generate --manual --name default --app-port 13000 --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/caddy in manual mode',
+        }),
+        'app-port': Flags.string({
+            description: 'Upstream NocoBase app port in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by caddy reverse_proxy in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
         }),
         host: Flags.string({
             description: 'Host exposed by the caddy site block, such as example.com or localhost',
@@ -35,9 +64,56 @@ export default class ProxyCaddyGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedAppPort = flags['app-port']?.trim() || undefined;
+            const appPort = normalizeProxyListenPort(requestedAppPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedAppPort && !appPort) {
+                this.error(`Invalid manual app port "${requestedAppPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !appPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--app-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getCaddyProxyDriver();
+            const runtimeContext = await resolveCaddyProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating caddy proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualCaddyProxyBundle({
+                    name,
+                    appPort,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
+                    : `Saved caddy proxy files for env "${name}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate caddy proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -56,7 +132,9 @@ export default class ProxyCaddyGenerate extends Command {
             const { bundle, status } = await writeCaddyProxyBundle(runtime, {
                 host: flags.host?.trim() || undefined,
                 port: normalizedPort,
-            }, runtimeContext);
+            }, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+            });
             succeedTask(status === 'created'
                 ? `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created app.caddy at ${bundle.appConfigPath}.`
                 : `Saved caddy proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed app.caddy at ${bundle.appConfigPath}.`);

package/dist/commands/proxy/nginx/generate.js

@@ -8,19 +8,52 @@
  */
 import { Command, Flags } from '@oclif/core';
 import { formatMissingManagedAppEnvMessage, resolveManagedAppRuntime, } from '../../../lib/app-runtime.js';
-import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
+import { getNginxProxyDriver, normalizeProxyListenPort, resolveNginxProxyRuntimeContext, writeManualNginxProxyBundle, writeNginxProxyBundle, } from '../../../lib/proxy-nginx.js';
 import { announceTargetEnv, failTask, startTask, succeedTask } from '../../../lib/ui.js';
 export default class ProxyNginxGenerate extends Command {
     static summary = 'Generate nginx proxy files for one managed env';
     static examples = [
+        '<%= config.bin %> proxy nginx generate --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com',
         '<%= config.bin %> proxy nginx generate --env app1 --host app1.example.com --port 8080',
+        '<%= config.bin %> proxy nginx generate --manual --name default --app-port 13000 --storage-path /path/to/storage --dist-root-path /path/to/dist-client --runtime-version 2.1.0',
     ];
     static flags = {
         env: Flags.string({
             char: 'e',
-            description: 'CLI env name to generate proxy files for',
-            required: true,
+            description: 'CLI env name to generate proxy files for. Defaults to the current env when omitted',
+        }),
+        manual: Flags.boolean({
+            description: 'Generate proxy files from explicit runtime flags instead of a saved env',
+            default: false,
+        }),
+        name: Flags.string({
+            description: 'Output bundle name used under .nocobase/proxy/nginx in manual mode',
+        }),
+        'app-port': Flags.string({
+            description: 'Upstream NocoBase app port in manual mode',
+        }),
+        'storage-path': Flags.string({
+            description: 'Path to the NocoBase storage directory in manual mode',
+        }),
+        'dist-root-path': Flags.string({
+            description: 'Path to the dist-client root directory used to generate index-v1.html and index-v2.html in manual mode',
+        }),
+        'runtime-version': Flags.string({
+            description: 'Frontend runtime version under dist-root-path in manual mode',
+        }),
+        'app-public-path': Flags.string({
+            description: 'Public base path served by the proxied app in manual mode. Defaults to /',
+        }),
+        'upstream-host': Flags.string({
+            description: 'Upstream host used by nginx proxy_pass in manual mode',
+        }),
+        'cdn-base-url': Flags.string({
+            description: 'Client asset CDN base URL used when generating runtime HTML',
+        }),
+        force: Flags.boolean({
+            description: 'Overwrite existing app.conf even when the managed block is missing',
+            default: false,
         }),
         host: Flags.string({
             description: 'Host exposed by the nginx entry config, such as example.com or localhost',
@@ -34,9 +67,56 @@ export default class ProxyNginxGenerate extends Command {
         const requestedEnv = flags.env?.trim() || undefined;
         const requestedPort = flags.port?.trim() || undefined;
         const normalizedPort = normalizeProxyListenPort(requestedPort);
+        const manual = Boolean(flags.manual);
         if (requestedPort && !normalizedPort) {
             this.error(`Invalid proxy entry port "${requestedPort}". Use an integer between 1 and 65535.`);
         }
+        if (manual && requestedEnv) {
+            this.error('`--manual` cannot be combined with `--env`.');
+        }
+        if (manual) {
+            const name = flags.name?.trim() || undefined;
+            const requestedAppPort = flags['app-port']?.trim() || undefined;
+            const appPort = normalizeProxyListenPort(requestedAppPort);
+            const storagePath = flags['storage-path']?.trim() || undefined;
+            const distRootPath = flags['dist-root-path']?.trim() || undefined;
+            const runtimeVersion = flags['runtime-version']?.trim() || undefined;
+            if (requestedAppPort && !appPort) {
+                this.error(`Invalid manual app port "${requestedAppPort}". Use an integer between 1 and 65535.`);
+            }
+            if (!name || !appPort || !storagePath || !distRootPath || !runtimeVersion) {
+                this.error('Manual mode requires `--name`, `--app-port`, `--storage-path`, `--dist-root-path`, and `--runtime-version`.');
+            }
+            const driver = await getNginxProxyDriver();
+            const runtimeContext = await resolveNginxProxyRuntimeContext();
+            announceTargetEnv(name);
+            startTask(`Generating nginx proxy config for env "${name}" with the ${driver} driver...`);
+            try {
+                const { bundle, status } = await writeManualNginxProxyBundle({
+                    name,
+                    appPort,
+                    storagePath,
+                    distRootPath,
+                    runtimeVersion,
+                    appPublicPath: flags['app-public-path']?.trim() || undefined,
+                    upstreamHost: flags['upstream-host']?.trim() || undefined,
+                    cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                }, {
+                    host: flags.host?.trim() || undefined,
+                    port: normalizedPort,
+                }, runtimeContext, {
+                    force: flags.force,
+                });
+                succeedTask(status === 'created'
+                    ? `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
+                    : `Saved nginx proxy files for env "${name}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);
+            }
+            catch (error) {
+                failTask(`Failed to generate nginx proxy config for env "${name}".`);
+                this.error(error instanceof Error ? error.message : String(error));
+            }
+            return;
+        }
         const runtime = await resolveManagedAppRuntime(requestedEnv);
         if (!runtime) {
             this.error(formatMissingManagedAppEnvMessage(requestedEnv));
@@ -55,7 +135,10 @@ export default class ProxyNginxGenerate extends Command {
             const { bundle, status } = await writeNginxProxyBundle(runtime, {
                 host: flags.host?.trim() || undefined,
                 port: normalizedPort,
-            }, runtimeContext);
+            }, runtimeContext, {
+                cdnBaseUrl: flags['cdn-base-url']?.trim() || undefined,
+                force: flags.force,
+            });
             succeedTask(status === 'created'
                 ? `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and created editable app entry config at ${bundle.appConfigPath}.`
                 : `Saved nginx proxy files for env "${runtime.envName}" under ${bundle.entryDir}, and refreshed editable app entry config at ${bundle.appConfigPath}.`);

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

@@ -225,8 +225,6 @@ export async function buildSavedDockerRunArgs(runtime, options) {
         '-d',
         '--name',
         runtime.containerName,
-        '--restart',
-        'always',
         '--network',
         runtime.workspaceName,
     ];