@digigov/cli-app 2.4.3-govgr-4752.27-07-26-12-24 → 2.5.0

package/CHANGELOG.md

@@ -1,19 +1,25 @@
 # Change Log - @digigov/cli-app
 
-<!-- This log was last generated on Mon, 27 Jul 2026 12:24:19 GMT and should not be manually modified. -->
+<!-- This log was last generated on Mon, 27 Jul 2026 17:23:56 GMT and should not be manually modified. -->
 
 <!-- Start content -->
 
-## 2.4.3-govgr-4752.27-07-26-12-24
+## 2.5.0
 
-Mon, 27 Jul 2026 12:24:19 GMT
+Mon, 27 Jul 2026 17:23:56 GMT
 
 ### Minor changes
 
-- Bump @digigov/cli-build to v2.4.3-govgr-4752.27-07-26-12-24
-- Bump @digigov/cli to v2.4.3-govgr-4752.27-07-26-12-24
-- Bump @digigov/cli-lint to v2.4.3-govgr-4752.27-07-26-12-24
-- Bump @digigov/css to v2.4.3-govgr-4752.27-07-26-12-24
+- Next.js 13.1.1 -> 16.2.12: builds now use static export (output: 'export', next export was removed in Next 14) while next dev keeps the regular dev server, and digigov app start serves out/ statically (-p/--port, -H/--hostname). Drop next-images/url-loader/babel-loader in favor of built-in static image imports, remove the rimraf peer dependency, and modernize the dev proxy to http-proxy-middleware v3 running in-process, arming websocket upgrades for ws: true proxy entries at startup so sockets reconnecting right after a restart are not dropped. (sangelopoulos@admin.grnet.gr)
+- Bump @digigov/cli-build to v2.5.0
+- Bump @digigov/cli to v2.5.0
+- Bump @digigov/cli-lint to v2.5.0
+- Bump @digigov/css to v2.5.0
+
+### Patches
+
+- default images.unoptimized in dev as well as build so dev image rendering matches the exported artifact and @digigov/nextjs Image's basePath prepend behaves the same everywhere (sangelopoulos@admin.grnet.gr)
+- route dev proxy and Next config output through the @digigov/cli logger instead of bare console calls (sangelopoulos@admin.grnet.gr)
 
 ## 2.4.2
 

package/next.common.cjs

@@ -1,8 +1,40 @@
 const lib = require('@digigov/cli/lib');
+const { logger } = require('@digigov/cli/lib/logger');
+const { PHASE_DEVELOPMENT_SERVER } = require('next/constants');
 let aliases = lib.aliases(true);
-const withImages = require('next-images');
 
-function makeNextConfig(dir) {
+// `next export` was removed in Next 14: outside the dev server the app must be
+// built with `output: 'export'` for `next build` to emit the static site in
+// `out/`. Export mode breaks `next dev` (and the dev proxy), so it can only be
+// applied per phase. The built-in i18n routing is unsupported under static
+// export.
+// Images are unoptimized in every phase (not just export, where the default
+// loader is unsupported): next/image never applies basePath to unoptimized
+// srcs, so @digigov/nextjs's Image prepends it manually — with the optimizer
+// active in dev that prepend would break, and dev would render differently
+// from the deployed artifact.
+function withStaticExport(config, phase) {
+  const common = {
+    ...config,
+    images: { unoptimized: true, ...config.images },
+  };
+  if (phase === PHASE_DEVELOPMENT_SERVER) return common;
+  const exported = {
+    output: 'export',
+    ...common,
+  };
+  if (exported.output === 'export' && exported.i18n) {
+    logger.warn(
+      'Built-in i18n routing is not supported with static export; ' +
+        'dropping the `i18n` config for this build. Locale routing must be ' +
+        'handled in userland (e.g. i18next without the Next.js `i18n` key).'
+    );
+    delete exported.i18n;
+  }
+  return exported;
+}
+
+function makeBaseConfig(dir) {
   const project = lib.resolveProject(dir);
   const digigov = project.digigov || {};
   if (digigov.aliases) {
@@ -11,15 +43,52 @@ function makeNextConfig(dir) {
       ...digigov.aliases,
     };
   }
-  console.log(`Creating aliases for ${Object.keys(aliases).join(', ')}`);
-  const nextConfig = withImages({
+  logger.info(`Creating aliases for ${Object.keys(aliases).join(', ')}`);
+  return {
     poweredByHeader: false,
     trailingSlash: true,
-    transpilePackages: Object.keys(aliases),
-  });
-  return nextConfig;
+    // Published-package consumers need more than the workspace aliases here.
+    // Turbopack bundles app imports of node_modules on the server, but
+    // externalizes the same imports made from inside node_modules (e.g. from
+    // @digigov/nextjs) — so any package holding shared state (React contexts,
+    // singletons) must be listed to unify every import onto one bundled
+    // module instance:
+    // - @digigov/nextjs also must never load as a Node external: its ESM dist
+    //   does `import Document from 'next/document'` (CJS), which only
+    //   resolves to the class under bundler interop — externally the default
+    //   import yields the whole exports object and SSR crashes.
+    // - @digigov/ui + react-core carry LinkProvider/I18NProvider contexts: a
+    //   split copy makes SSR fall back to plain anchors (no next/link, no
+    //   trailing-slash normalization → hydration mismatch).
+    // - i18next/react-i18next are singletons initialized once by initI18n():
+    //   a split copy renders raw translation keys during SSR.
+    // Inside the SDK workspace the aliases already cover the workspace libs;
+    // the Set just dedupes.
+    transpilePackages: [
+      ...new Set([
+        ...Object.keys(aliases),
+        '@digigov/nextjs',
+        '@digigov/ui',
+        '@digigov/react-core',
+        '@digigov/react-icons',
+        '@digigov/form',
+        'i18next',
+        'react-i18next',
+      ]),
+    ],
+  };
 }
+
+const baseConfig = makeBaseConfig();
+
+function makeNextConfig(dir) {
+  const base = dir ? makeBaseConfig(dir) : baseConfig;
+  return (phase) => withStaticExport(base, phase);
+}
+
 module.exports = {
+  baseConfig,
   makeNextConfig,
+  withStaticExport,
   config: makeNextConfig(),
 };

package/nextrc.cjs

@@ -1,5 +1,6 @@
 const { makeConfig } = require('@digigov/cli/lib');
+const { baseConfig, withStaticExport } = require('./next.common.cjs');
 
 module.exports = (overrides) => {
-  return makeConfig(overrides, require('./next.common.cjs').config);
+  return (phase) => withStaticExport(makeConfig(overrides, baseConfig), phase);
 };

package/package.json

@@ -1,33 +1,29 @@
 {
   "name": "@digigov/cli-app",
-  "version": "2.4.3-govgr-4752.27-07-26-12-24",
+  "version": "2.5.0",
   "description": "@digigov developer cli tool",
   "main": "./index.js",
   "type": "module",
   "author": "GRNET Developers <devs@lists.grnet.gr>",
   "license": "BSD-2-Clause",
   "dependencies": {
-    "babel-loader": "8.2.1",
-    "express": "4.17.1",
-    "http-proxy-middleware": "1.0.3",
-    "next-images": "1.3.0",
-    "url-loader": "4.1.1",
-    "next": "13.1.1",
+    "express": "4.22.2",
+    "http-proxy-middleware": "3.0.5",
+    "next": "16.2.12",
     "commander": "12.1.0",
     "globby": "11.0.0",
     "publint": "0.1.8",
-    "@digigov/cli-build": "2.4.3-govgr-4752.27-07-26-12-24"
+    "@digigov/cli-build": "2.5.0"
   },
   "peerDependencies": {
-    "rimraf": "3.0.2",
     "typescript": "5.6.2",
     "@types/node": "20.17.24",
     "@types/react": "19.1.3",
     "autoprefixer": "10.4.16",
     "postcss": "8.4.4",
     "tailwindcss": "3.4.13",
-    "@digigov/cli": "2.4.3-govgr-4752.27-07-26-12-24",
-    "@digigov/css": "2.4.3-govgr-4752.27-07-26-12-24"
+    "@digigov/cli": "2.5.0",
+    "@digigov/css": "2.5.0"
   },
   "exports": {
     ".": "./index.js",
@@ -45,8 +41,8 @@
     "typescript": "5.6.2",
     "eslint": "9.16.0",
     "prettier": "3.4.2",
-    "@digigov/cli": "2.4.3-govgr-4752.27-07-26-12-24",
-    "@digigov/cli-lint": "2.4.3-govgr-4752.27-07-26-12-24"
+    "@digigov/cli": "2.5.0",
+    "@digigov/cli-lint": "2.5.0"
   },
   "scripts": {
     "publint": "publint",

package/subcommands/build.js

@@ -1,14 +1,22 @@
-import { DigigovCommand } from '@digigov/cli/lib';
+import fs from 'fs/promises';
+import path from 'path';
+
+import { DigigovCommand, resolveProject } from '@digigov/cli/lib';
 import { EXEC_CONFIG } from '../common.js';
 
 const buildCommand = new DigigovCommand('build');
 
+const project = resolveProject();
+
 buildCommand
   .argument('[...args]', 'Arguments to pass to the `next build` command')
   .helpOption(false)
   .allowUnknownOption()
   .action(async (args = [], _, ctx) => {
-    await ctx.exec('rimraf', ['out']);
+    await fs.rm(path.join(project.root, 'out'), {
+      recursive: true,
+      force: true,
+    });
     await ctx.exec('next', ['build', ...args], EXEC_CONFIG);
   });
 

package/subcommands/dev.js

@@ -1,11 +1,7 @@
 import { DigigovCommand, resolveProject, logger } from '@digigov/cli/lib';
 import { EXEC_CONFIG } from '../common.js';
 
-import path from 'path';
-import { fileURLToPath } from 'url';
-
 const { digigov } = resolveProject();
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
 
 const devCommand = new DigigovCommand('dev');
 
@@ -16,11 +12,11 @@ devCommand
   .action(async (args = [], _, ctx) => {
     logger.info('Starting development server...');
     if (digigov && digigov.proxy) {
-      await ctx.exec(
-        'node',
-        [path.resolve(__dirname, '../utils/proxy-server.js')],
-        EXEC_CONFIG
-      );
+      // The proxy server wraps its own Next dev instance and replaces
+      // `next dev` entirely; running both would bind two servers. It starts
+      // listening on import.
+      await import('../utils/proxy-server.js');
+      return;
     }
     await ctx.exec('next', ['dev', ...(args ?? [])], EXEC_CONFIG);
   });

package/subcommands/export.js

@@ -1,16 +1,26 @@
-import { DigigovCommand } from '@digigov/cli/lib';
+import fs from 'fs/promises';
+import path from 'path';
+
+import { DigigovCommand, resolveProject } from '@digigov/cli/lib';
 import { EXEC_CONFIG } from '../common.js';
 
 const exportCommand = new DigigovCommand('export');
 
+const project = resolveProject();
+
+// `next export` was removed in Next 14; `next build` itself emits `out/`
+// because the shared config sets `output: 'export'` outside the dev phase.
+// Kept as an alias of `build` so existing `digigov app export` setups work.
 exportCommand
-  .argument('[...args]', 'Arguments to pass to the `next export` command')
+  .argument('[...args]', 'Arguments to pass to the `next build` command')
   .helpOption(false)
   .allowUnknownOption()
   .action(async (args = [], _, ctx) => {
-    await ctx.exec('rimraf', ['out']);
-    await ctx.exec('next', ['build']);
-    await ctx.exec('next', ['export', ...args], EXEC_CONFIG);
+    await fs.rm(path.join(project.root, 'out'), {
+      recursive: true,
+      force: true,
+    });
+    await ctx.exec('next', ['build', ...args], EXEC_CONFIG);
   });
 
 export default exportCommand;

package/subcommands/start.js

@@ -1,6 +1,9 @@
 import fs from 'fs';
+import { createRequire } from 'module';
 
-import { DigigovCommand, resolveProject } from '@digigov/cli/lib';
+import express from 'express';
+import { PHASE_PRODUCTION_SERVER } from 'next/constants.js';
+import { DigigovCommand, resolveProject, logger } from '@digigov/cli/lib';
 import { EXEC_CONFIG } from '../common.js';
 import path from 'path';
 
@@ -8,15 +11,60 @@ const startCommand = new DigigovCommand('start');
 
 const project = resolveProject();
 
+// `next start` does not support `output: 'export'`, so serve the exported
+// site the same way production does (static files behind a web server).
 startCommand
-  .argument('[...args]', 'Arguments to pass to the `next start` command')
-  .helpOption(false)
-  .allowUnknownOption()
-  .action(async (args = [], _, ctx) => {
-    if (!fs.existsSync(path.join(project.root, '.next'))) {
-      await ctx.exec('next', ['build']);
+  .option(
+    '-p, --port <port>',
+    'Port to listen on',
+    process.env['PORT'] ?? '3000'
+  )
+  .option('-H, --hostname <hostname>', 'Hostname to bind to', '0.0.0.0')
+  .action(async (options, ctx) => {
+    const port = parseInt(options.port, 10);
+    if (Number.isNaN(port)) {
+      logger.error(`Invalid port: ${options.port}`);
+      process.exit(1);
     }
-    await ctx.exec('next', ['start', ...args], EXEC_CONFIG);
+    const outDir = path.join(project.root, 'out');
+    if (!fs.existsSync(outDir)) {
+      await ctx.exec('next', ['build'], EXEC_CONFIG);
+    }
+    // The exported HTML references pages and assets under `basePath`, so the
+    // static site must be mounted there — as `next start` used to do.
+    const configPath = path.join(project.root, 'next.config.js');
+    let conf = {};
+    if (fs.existsSync(configPath)) {
+      const confModule = createRequire(configPath)(configPath);
+      conf =
+        typeof confModule === 'function'
+          ? await confModule(PHASE_PRODUCTION_SERVER, { defaultConfig: {} })
+          : confModule;
+    }
+    const basePath = conf.basePath ?? '';
+    const server = express();
+    server.use(
+      basePath || '/',
+      express.static(outDir, { extensions: ['html'] })
+    );
+    server.use((_req, res) => {
+      const notFoundPage = path.join(outDir, '404.html');
+      if (fs.existsSync(notFoundPage)) {
+        res.status(404).sendFile(notFoundPage);
+      } else {
+        res.status(404).send('Not Found');
+      }
+    });
+    server
+      .listen(port, options.hostname, () => {
+        logger.info(
+          `Serving ${outDir} on http://${options.hostname}:${port}${basePath}`
+        );
+      })
+      .on('error', (err) => {
+        logger.error(`Unable to start server: ${err.message}`);
+        process.exit(1);
+      });
   });
 
 export default startCommand;

package/utils/proxy-server.js

@@ -2,8 +2,15 @@ import express from 'express';
 import next from 'next';
 import path from 'path';
 import { createRequire } from 'module';
+import { createProxyMiddleware } from 'http-proxy-middleware';
+// `next` publishes no `exports` map, so the subpath needs the explicit
+// extension to resolve under ESM.
+import {
+  PHASE_DEVELOPMENT_SERVER,
+  PHASE_PRODUCTION_SERVER,
+} from 'next/constants.js';
 
-import { resolveProject } from '@digigov/cli/lib';
+import { resolveProject, logger } from '@digigov/cli/lib';
 
 const port = parseInt(process.env['PORT'] ?? '3000', 10);
 const isDev = process.env.NODE_ENV !== 'production';
@@ -12,37 +19,73 @@ const project = resolveProject();
 const devProxy = project.digigov.proxy;
 
 const require = createRequire(import.meta.url);
-const conf = require(path.join(project.root, 'next.config.js'));
+const confModule = require(path.join(project.root, 'next.config.js'));
 
-const app = next.default({
+// nextrc exports a phase → config function; `next({ conf })` spreads the
+// value without invoking it, so the phase must be resolved here.
+const conf =
+  typeof confModule === 'function'
+    ? await confModule(
+        isDev ? PHASE_DEVELOPMENT_SERVER : PHASE_PRODUCTION_SERVER,
+        { defaultConfig: {} }
+      )
+    : confModule;
+
+// Next 16 removed the CJS `.default` interop export: `module.exports` itself is
+// the server factory (on 13 too), but the d.ts still types the module as a
+// non-callable namespace — hence the cast.
+const createNextServer = /** @type {import('next')['default']} */ (
+  /** @type {unknown} */ (next)
+);
+
+const app = createNextServer({
   dir: project.root, // base directory where everything is, could move to src later
   dev: isDev,
   conf,
 });
 const handle = app.getRequestHandler();
 
-app
-  .prepare()
-  .then(() => {
-    const server = express();
-
-    // Set up the proxy.
-    if (isDev && devProxy) {
-      const { createProxyMiddleware } = require('http-proxy-middleware');
-      Object.keys(devProxy).forEach(function (context) {
-        server.use(createProxyMiddleware(context, devProxy[context]));
-      });
+try {
+  await app.prepare();
+  const server = express();
+
+  // Set up the proxy.
+  const wsProxies = [];
+  if (isDev && devProxy) {
+    for (const [pathFilter, options] of Object.entries(devProxy)) {
+      const proxy = createProxyMiddleware({ pathFilter, ...options });
+      server.use(proxy);
+      if (options.ws) {
+        wsProxies.push(proxy);
+      }
     }
+  }
 
-    // Default catch-all handler to allow Next.js to handle all other routes
-    server.all('*', (req, res) => handle(req, res));
+  // Default catch-all handler to allow Next.js to handle all other routes
+  server.use((req, res) => handle(req, res));
 
-    server.listen(port, () => {
-      console.log(`> Ready on port ${port}`);
-    });
-    return;
-  })
-  .catch((err) => {
-    console.log('An error occurred, unable to start the server');
-    console.log(err);
+  const httpServer = server.listen(port, () => {
+    logger.info(`Ready on port ${port}`);
   });
+
+  // Next and http-proxy-middleware each register their own `upgrade` listener,
+  // but only lazily — on the first HTTP request they see. A websocket that
+  // connects right after a restart, before any HTTP request (e.g. an open tab
+  // reconnecting through a `ws: true` proxy), finds no listener and hangs.
+  // Arm the ws proxies up front: `upgrade` checks its own pathFilter and
+  // no-ops once the proxy's internal listener exists, so nothing is handled
+  // twice. Next needs no arming — its HMR socket always follows a page load.
+  if (wsProxies.length > 0) {
+    httpServer.on('upgrade', (req, socket, head) => {
+      for (const proxy of wsProxies) {
+        proxy.upgrade(req, socket, head);
+      }
+    });
+  }
+} catch (err) {
+  logger.error(
+    'Unable to start the server:',
+    err instanceof Error ? err.stack : err
+  );
+  process.exit(1);
+}