@vantran-se/openchamber-web 1.22.1 → 1.23.0

package/server/lib/opencode/openchamber-routes.js

@@ -29,11 +29,13 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
     readSettingsFromDiskMigrated,
     fetchFreeZenModels,
     getCachedZenModels,
+    desktopUpdater,
   } = dependencies;
 
+  let desktopRestartError = null;
+
   app.get('/api/openchamber/update-check', async (req, res) => {
     try {
-      const { checkForUpdates } = await import('../package-manager.js');
       const parseString = (value) => (typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined);
       const parseReportUsage = (value) => {
         if (typeof value !== 'string') return true;
@@ -49,8 +51,7 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
         return 'desktop';
       };
       const userAgent = typeof req.headers['user-agent'] === 'string' ? req.headers['user-agent'] : '';
-
-      const updateInfo = await checkForUpdates({
+      const updateRequest = {
         appType: parseString(req.query.appType),
         deviceClass: parseString(req.query.deviceClass) || inferDeviceClass(userAgent),
         platform: parseString(req.query.platform),
@@ -59,7 +60,31 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
         currentVersion: parseString(req.query.currentVersion),
         installId: parseString(req.query.installId),
         reportUsage: parseReportUsage(parseString(req.query.reportUsage)),
-      });
+      };
+      let updateInfo;
+      if (process.env.OPENCHAMBER_RUNTIME === 'desktop' && updateRequest.appType === 'web') {
+        if (desktopRestartError && req.query.updateStatus === 'true') {
+          return res.status(503).json({
+            code: 'DESKTOP_UPDATE_RESTART_FAILED',
+            error: desktopRestartError,
+          });
+        }
+        if (typeof desktopUpdater?.check !== 'function') {
+          return res.status(503).json({
+            available: false,
+            code: 'DESKTOP_UPDATER_UNAVAILABLE',
+            error: 'The desktop updater is not available.',
+          });
+        }
+        updateInfo = {
+          ...await desktopUpdater.check(),
+          packageManager: 'electron',
+          updateOwner: 'electron-updater',
+        };
+      } else {
+        const { checkForUpdates } = await import('../package-manager.js');
+        updateInfo = await checkForUpdates(updateRequest);
+      }
       res.json(updateInfo);
     } catch (error) {
       console.error('Failed to check for updates:', error);
@@ -72,6 +97,41 @@ export const registerOpenChamberRoutes = (app, dependencies) => {
 
   app.post('/api/openchamber/update-install', async (_req, res) => {
     try {
+      if (process.env.OPENCHAMBER_RUNTIME === 'desktop') {
+        if (typeof desktopUpdater?.install !== 'function' || typeof desktopUpdater?.restart !== 'function') {
+          return res.status(503).json({
+            code: 'DESKTOP_UPDATER_UNAVAILABLE',
+            error: 'The desktop updater is not available.',
+          });
+        }
+
+        desktopRestartError = null;
+        const updateInfo = await desktopUpdater.install();
+        if (!updateInfo?.available) {
+          return res.status(400).json({ error: 'No update available' });
+        }
+
+        res.json({
+          success: true,
+          message: 'Desktop update downloaded, host will restart shortly',
+          version: updateInfo.version,
+          packageManager: 'electron',
+          updateOwner: 'electron-updater',
+          autoRestart: true,
+          restartManager: 'electron-updater',
+        });
+
+        setImmediate(() => {
+          Promise.resolve()
+            .then(() => desktopUpdater.restart())
+            .catch((error) => {
+              desktopRestartError = error instanceof Error ? error.message : 'Failed to restart after desktop update';
+              console.error('Failed to restart after desktop update:', error);
+            });
+        });
+        return;
+      }
+
       const { spawn: spawnChild, spawnSync } = await import('child_process');
       const {
         checkForUpdates,

package/server/lib/opencode/openchamber-routes.test.js

@@ -18,7 +18,7 @@ const childProcess = await import('child_process');
 const packageManager = await import('../package-manager.js');
 const { registerOpenChamberRoutes } = await import('./openchamber-routes.js');
 
-const createApp = ({ environment = {}, storedOptions = {} } = {}) => {
+const createApp = ({ environment = {}, storedOptions = {}, desktopUpdater } = {}) => {
   const app = express();
   const dependencies = {
     fs: {
@@ -47,6 +47,7 @@ const createApp = ({ environment = {}, storedOptions = {} } = {}) => {
     readSettingsFromDiskMigrated: vi.fn(),
     fetchFreeZenModels: vi.fn(),
     getCachedZenModels: vi.fn(),
+    desktopUpdater,
   };
 
   registerOpenChamberRoutes(app, dependencies);
@@ -62,7 +63,7 @@ beforeEach(() => {
     packageManager: 'npm',
   });
   packageManager.getUpdateCommand.mockReturnValue(
-    'npm install -g @vantran-se/openchamber-web@latest --registry=https://npm.pkg.github.com',
+    'npm install -g @vantran-se/openchamber-web@latest --registry=https://registry.npmjs.org',
   );
 });
 
@@ -71,6 +72,132 @@ afterEach(() => {
   vi.clearAllMocks();
 });
 
+describe('OpenChamber desktop host update route', () => {
+  it('reports a restart rejection until the user retries installation', async () => {
+    const desktopUpdater = {
+      check: vi.fn(async () => ({ available: true, currentVersion: '1.17.0', version: '1.17.1' })),
+      install: vi.fn(async () => ({ available: true, version: '1.17.1' })),
+      restart: vi.fn().mockRejectedValueOnce(new Error('Signature rejected')).mockResolvedValue(undefined),
+    };
+    const { app } = createApp({ environment: { OPENCHAMBER_RUNTIME: 'desktop' }, desktopUpdater });
+    const logError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await request(app).post('/api/openchamber/update-install').expect(200);
+    await new Promise(resolve => setImmediate(resolve));
+    await request(app).get('/api/openchamber/update-check?appType=web&reportUsage=false&updateStatus=true').expect(503, {
+      code: 'DESKTOP_UPDATE_RESTART_FAILED', error: 'Signature rejected',
+    });
+    expect(desktopUpdater.check).not.toHaveBeenCalled();
+    expect(logError).toHaveBeenCalledOnce();
+    // Availability remains reachable after a browser reload, so users can retry.
+    await request(app).get('/api/openchamber/update-check?appType=web&reportUsage=false').expect(200);
+
+    await request(app).post('/api/openchamber/update-install').expect(200);
+    await new Promise(resolve => setImmediate(resolve));
+    const response = await request(app).get('/api/openchamber/update-check?appType=web&reportUsage=false').expect(200);
+    expect(response.body.currentVersion).toBe('1.17.0');
+    expect(response.body.updateOwner).toBe('electron-updater');
+    expect(packageManager.checkForUpdates).not.toHaveBeenCalled();
+  });
+
+  it('rejects native checks without a bridge and preserves explicit non-web checks', async () => {
+    const { app } = createApp({ environment: { OPENCHAMBER_RUNTIME: 'desktop' } });
+    await request(app).get('/api/openchamber/update-check?appType=web').expect(503, {
+      available: false, code: 'DESKTOP_UPDATER_UNAVAILABLE', error: 'The desktop updater is not available.',
+    });
+    expect(packageManager.checkForUpdates).not.toHaveBeenCalled();
+    await request(app).get('/api/openchamber/update-check?appType=desktop-electron').expect(200);
+    expect(packageManager.checkForUpdates).toHaveBeenCalledOnce();
+  });
+
+  it('uses electron-updater to check for Web client updates', async () => {
+    const desktopUpdater = {
+      check: vi.fn(async () => ({
+        available: true,
+        currentVersion: '1.17.0',
+        version: '1.17.1',
+      })),
+      install: vi.fn(),
+      restart: vi.fn(),
+    };
+    const { app } = createApp({
+      environment: {
+        OPENCHAMBER_RUNTIME: 'desktop',
+      },
+      desktopUpdater,
+    });
+
+    await request(app)
+      .get('/api/openchamber/update-check?appType=web&reportUsage=false')
+      .expect(200, {
+        available: true,
+        currentVersion: '1.17.0',
+        version: '1.17.1',
+        packageManager: 'electron',
+        updateOwner: 'electron-updater',
+      });
+
+    expect(desktopUpdater.check).toHaveBeenCalledOnce();
+    expect(packageManager.checkForUpdates).not.toHaveBeenCalled();
+  });
+
+  it('installs through electron-updater and restarts after responding', async () => {
+    const desktopUpdater = {
+      check: vi.fn(),
+      install: vi.fn(async () => ({
+        available: true,
+        version: '1.17.1',
+      })),
+      restart: vi.fn(),
+    };
+    const { app } = createApp({
+      environment: {
+        OPENCHAMBER_RUNTIME: 'desktop',
+      },
+      desktopUpdater,
+    });
+
+    await request(app)
+      .post('/api/openchamber/update-install')
+      .expect(200, {
+        success: true,
+        message: 'Desktop update downloaded, host will restart shortly',
+        version: '1.17.1',
+        packageManager: 'electron',
+        updateOwner: 'electron-updater',
+        autoRestart: true,
+        restartManager: 'electron-updater',
+      });
+    await new Promise((resolve) => setImmediate(resolve));
+
+    expect(desktopUpdater.install).toHaveBeenCalledOnce();
+    expect(desktopUpdater.restart).toHaveBeenCalledOnce();
+    expect(packageManager.checkForUpdates).not.toHaveBeenCalled();
+    expect(packageManager.detectPackageManagerDetails).not.toHaveBeenCalled();
+    expect(packageManager.getUpdateCommand).not.toHaveBeenCalled();
+    expect(childProcess.spawn).not.toHaveBeenCalled();
+    expect(childProcess.spawnSync).not.toHaveBeenCalled();
+  });
+
+  it('fails safely when the Electron updater bridge is unavailable', async () => {
+    const { app } = createApp({
+      environment: {
+        OPENCHAMBER_RUNTIME: 'desktop',
+      },
+    });
+
+    await request(app)
+      .post('/api/openchamber/update-install')
+      .expect(503, {
+        code: 'DESKTOP_UPDATER_UNAVAILABLE',
+        error: 'The desktop updater is not available.',
+      });
+
+    expect(packageManager.checkForUpdates).not.toHaveBeenCalled();
+    expect(childProcess.spawn).not.toHaveBeenCalled();
+  });
+});
+
 describe('OpenChamber foreground update route', () => {
   it('rejects a foreground update when the server is not owned by systemd', async () => {
     const { app } = createApp();
@@ -133,7 +260,7 @@ describe('OpenChamber foreground update route', () => {
       '--setenv=PATH=/home/syu/.npm-global/bin:/usr/bin:/bin',
       '/bin/sh',
       '-c',
-      "set -eu\nnpm install -g @vantran-se/openchamber-web@latest --registry=https://npm.pkg.github.com\nsystemctl --user restart 'openchamber@wsl.service'",
+      "set -eu\nnpm install -g @vantran-se/openchamber-web@latest --registry=https://registry.npmjs.org\nsystemctl --user restart 'openchamber@wsl.service'",
     ], {
       encoding: 'utf8',
       stdio: ['ignore', 'pipe', 'pipe'],

package/server/lib/opencode/plugins.js

@@ -1,8 +1,8 @@
 import fs from 'fs';
-import os from 'os';
 import path from 'path';
 import {
   AGENT_SCOPE,
+  OPENCODE_CONFIG_DIR,
   readConfigFile,
   readConfigLayer,
   writeConfig,
@@ -71,7 +71,7 @@ function getActiveOpencodeConfigDir() {
   if (customConfigPath) {
     return path.dirname(path.resolve(customConfigPath));
   }
-  return path.join(os.homedir(), '.config', 'opencode');
+  return OPENCODE_CONFIG_DIR;
 }
 
 function getActiveUserConfigPaths() {

package/server/lib/opencode/providers.js

@@ -152,6 +152,37 @@ function validateCustomProviderConfig(providerId, config, options = {}) {
   return { ok: true, value: { providerId, config: normalized } };
 }
 
+function mergeCustomProviderConfig(existingValue, normalizedConfig) {
+  const existing = isPlainObject(existingValue) ? existingValue : {};
+  const existingOptions = isPlainObject(existing.options) ? existing.options : {};
+  const normalizedOptions = isPlainObject(normalizedConfig.options) ? normalizedConfig.options : {};
+  const mergedOptions = { ...existingOptions, ...normalizedOptions };
+  if (!Object.prototype.hasOwnProperty.call(normalizedOptions, 'headers')) {
+    delete mergedOptions.headers;
+  }
+
+  const existingModels = isPlainObject(existing.models) ? existing.models : {};
+  const normalizedModels = isPlainObject(normalizedConfig.models) ? normalizedConfig.models : {};
+  const mergedModels = Object.fromEntries(
+    Object.entries(normalizedModels).map(([modelId, normalizedModel]) => {
+      const existingModel = isPlainObject(existingModels[modelId]) ? existingModels[modelId] : {};
+      const nextModel = isPlainObject(normalizedModel) ? normalizedModel : {};
+      return [modelId, { ...existingModel, ...nextModel }];
+    }),
+  );
+
+  const merged = {
+    ...existing,
+    ...normalizedConfig,
+    options: mergedOptions,
+    models: mergedModels,
+  };
+  if (!Object.prototype.hasOwnProperty.call(normalizedConfig, 'env')) {
+    delete merged.env;
+  }
+  return merged;
+}
+
 /**
  * Persist (create or update) a custom provider block in OpenCode user/project/custom config.
  * Does not write secrets — API keys remain in auth.json via the OpenCode auth API.
@@ -183,8 +214,19 @@ function upsertProviderConfig(providerId, config, workingDirectory, scope = 'use
 
   const targetConfig = getConfigForPath(layers, targetPath);
   const providerConfig = isPlainObject(targetConfig.provider) ? { ...targetConfig.provider } : {};
-  providerConfig[validated.value.providerId] = validated.value.config;
+  const providersAlias = isPlainObject(targetConfig.providers) ? { ...targetConfig.providers } : {};
+  const existingProvider = providerConfig[validated.value.providerId] ?? providersAlias[validated.value.providerId];
+  const mergedConfig = mergeCustomProviderConfig(existingProvider, validated.value.config);
+  providerConfig[validated.value.providerId] = mergedConfig;
   targetConfig.provider = providerConfig;
+  if (Object.prototype.hasOwnProperty.call(providersAlias, validated.value.providerId)) {
+    delete providersAlias[validated.value.providerId];
+    if (Object.keys(providersAlias).length === 0) {
+      delete targetConfig.providers;
+    } else {
+      targetConfig.providers = providersAlias;
+    }
+  }
 
   if (Array.isArray(targetConfig.disabled_providers)) {
     targetConfig.disabled_providers = targetConfig.disabled_providers.filter(
@@ -198,7 +240,7 @@ function upsertProviderConfig(providerId, config, workingDirectory, scope = 'use
   return {
     providerId: validated.value.providerId,
     path: writePath,
-    config: validated.value.config,
+    config: mergedConfig,
   };
 }
 

package/server/lib/opencode/providers.test.js

@@ -9,6 +9,7 @@ import {
   getProviderSources,
   removeProviderConfig,
 } from './providers.js';
+import { OPENCODE_CONFIG_DIR } from './shared.js';
 
 let projectDir;
 
@@ -162,6 +163,132 @@ describe('custom provider config persistence', () => {
     expect(written.disabled_providers).toEqual(['other']);
   });
 
+  test('upsertProviderConfig preserves unmanaged provider and model metadata', () => {
+    const configPath = path.join(projectDir, 'opencode.json');
+    writeJson(configPath, {
+      provider: {
+        'campus-llm': {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Old',
+          customProviderField: { owner: 'user' },
+          env: ['OLD_KEY'],
+          options: {
+            baseURL: 'https://old.example.edu/v1',
+            headers: { 'X-Old': '1' },
+            timeout: 45_000,
+          },
+          models: {
+            retained: {
+              name: 'Old retained name',
+              reasoning: true,
+              attachment: true,
+              tool_call: true,
+              modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+              limit: { context: 1_050_000, input: 922_000, output: 128_000 },
+              options: { instructions: 'Keep this instruction' },
+              variants: {
+                low: { reasoningEffort: 'low' },
+                high: { reasoningEffort: 'high' },
+              },
+              customModelField: { source: 'manual' },
+            },
+            removed: {
+              name: 'Remove me',
+              reasoning: true,
+            },
+          },
+        },
+      },
+    });
+
+    upsertProviderConfig('campus-llm', {
+      name: 'Campus LLM',
+      options: { baseURL: 'https://new.example.edu/v1' },
+      models: {
+        retained: { name: 'Retained model' },
+        added: { name: 'Added model' },
+      },
+    }, projectDir, 'project', { hasStoredAuth: true });
+
+    const written = readJson(configPath).provider['campus-llm'];
+    expect(written).toEqual({
+      npm: '@ai-sdk/openai-compatible',
+      name: 'Campus LLM',
+      customProviderField: { owner: 'user' },
+      options: {
+        baseURL: 'https://new.example.edu/v1',
+        timeout: 45_000,
+      },
+      models: {
+        retained: {
+          name: 'Retained model',
+          reasoning: true,
+          attachment: true,
+          tool_call: true,
+          modalities: { input: ['text', 'image', 'pdf'], output: ['text'] },
+          limit: { context: 1_050_000, input: 922_000, output: 128_000 },
+          options: { instructions: 'Keep this instruction' },
+          variants: {
+            low: { reasoningEffort: 'low' },
+            high: { reasoningEffort: 'high' },
+          },
+          customModelField: { source: 'manual' },
+        },
+        added: { name: 'Added model' },
+      },
+    });
+  });
+
+  test('upsertProviderConfig preserves metadata while migrating the legacy providers alias', () => {
+    const configPath = path.join(projectDir, 'opencode.json');
+    writeJson(configPath, {
+      providers: {
+        legacy: {
+          name: 'Legacy provider',
+          options: { baseURL: 'https://old.example.com/v1', timeout: 30_000 },
+          models: { model: { name: 'Old model', reasoning: true } },
+        },
+      },
+    });
+
+    upsertProviderConfig('legacy', {
+      name: 'Updated provider',
+      options: { baseURL: 'https://new.example.com/v1' },
+      models: { model: { name: 'Updated model' } },
+    }, projectDir, 'project', { hasStoredAuth: true });
+
+    const written = readJson(configPath);
+    expect(written.providers).toBeUndefined();
+    expect(written.provider.legacy).toEqual({
+      npm: '@ai-sdk/openai-compatible',
+      name: 'Updated provider',
+      options: { baseURL: 'https://new.example.com/v1', timeout: 30_000 },
+      models: { model: { name: 'Updated model', reasoning: true } },
+    });
+  });
+
+  test('migrating one legacy providers entry keeps the other legacy entries', () => {
+    const configPath = path.join(projectDir, 'opencode.json');
+    writeJson(configPath, {
+      providers: {
+        legacy: { name: 'Legacy provider', options: { baseURL: 'https://old.example.com/v1' }, models: { model: { name: 'Old model' } } },
+        untouched: { name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
+      },
+    });
+
+    upsertProviderConfig('legacy', {
+      name: 'Updated provider',
+      options: { baseURL: 'https://new.example.com/v1' },
+      models: { model: { name: 'Updated model' } },
+    }, projectDir, 'project', { hasStoredAuth: true });
+
+    const written = readJson(configPath);
+    expect(written.providers).toEqual({
+      untouched: { name: 'Untouched', options: { baseURL: 'https://other.example.com/v1' }, models: { model: { name: 'Other model' } } },
+    });
+    expect(written.provider.legacy.name).toBe('Updated provider');
+  });
+
   test('upsert then remove restores absence', () => {
     upsertProviderConfig('temp-provider', {
       name: 'Temp',
@@ -230,8 +357,8 @@ describe('custom provider config persistence', () => {
     expect(sources.sources.custom.exists).toBe(false);
 
     for (const userPath of [
-      path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
-      path.join(os.homedir(), '.config', 'opencode', 'config.json'),
+      path.join(OPENCODE_CONFIG_DIR, 'opencode.json'),
+      path.join(OPENCODE_CONFIG_DIR, 'config.json'),
     ]) {
       if (!fs.existsSync(userPath)) continue;
       const userConfig = readJson(userPath);
@@ -269,8 +396,8 @@ describe('custom provider config persistence', () => {
       expect(sources.sources.project.exists).toBe(false);
 
       for (const userPath of [
-        path.join(os.homedir(), '.config', 'opencode', 'opencode.json'),
-        path.join(os.homedir(), '.config', 'opencode', 'config.json'),
+        path.join(OPENCODE_CONFIG_DIR, 'opencode.json'),
+        path.join(OPENCODE_CONFIG_DIR, 'config.json'),
       ]) {
         if (!fs.existsSync(userPath)) continue;
         const userConfig = readJson(userPath);

package/server/lib/opencode/routes.js

@@ -1,12 +1,13 @@
 import express from 'express';
 import { createProjectIdFromPath } from '../projects/project-id.js';
 import fs from 'fs';
-import os from 'os';
 import path from 'path';
 import {
   buildDeferredRestartResponse,
 } from './config-mutation-response.js';
 import { getClaudeCliAuthStatus } from './claude-cli-auth.js';
+import { OPENCODE_CONFIG_DIR } from './shared.js';
+import { settingsSurfaceOf } from './settings-files.js';
 
 export const registerOpenCodeRoutes = (app, dependencies) => {
   const {
@@ -208,9 +209,10 @@ ${desktopReturn ? `<a class="return" href="openchamber://focus/mcp-auth">Return
     }
   };
 
-  app.get('/api/config/settings', async (_req, res) => {
+  app.get('/api/config/settings', async (req, res) => {
     try {
-      const settings = await readSettingsFromDiskMigrated();
+      // The surface kind resolves the per-surface profile keys; absent means base.
+      const settings = await readSettingsFromDiskMigrated({ surface: settingsSurfaceOf(req) });
       res.json(formatSettingsResponse(settings));
     } catch (error) {
       console.error('Failed to read settings:', error);
@@ -422,7 +424,7 @@ ${desktopReturn ? `<a class="return" href="openchamber://focus/mcp-auth">Return
 
   app.put('/api/config/settings', async (req, res) => {
     try {
-      const updated = await persistSettings(req.body ?? {});
+      const updated = await persistSettings(req.body ?? {}, { surface: settingsSurfaceOf(req) });
       res.json(updated);
     } catch (error) {
       console.error('[API:PUT /api/config/settings] Failed to save settings:', error);
@@ -807,7 +809,7 @@ ${desktopReturn ? `<a class="return" href="openchamber://focus/mcp-auth">Return
   });
 
   // Behavior / Global AGENTS.md endpoints
-  const AGENTS_MD_PATH = path.join(os.homedir(), '.config', 'opencode', 'AGENTS.md');
+  const AGENTS_MD_PATH = path.join(OPENCODE_CONFIG_DIR, 'AGENTS.md');
   const MAX_BEHAVIOR_PROMPT_SIZE = 1024 * 1024; // 1 MB
 
   app.get('/api/behavior/agents-md', async (_req, res) => {
@@ -815,10 +817,10 @@ ${desktopReturn ? `<a class="return" href="openchamber://focus/mcp-auth">Return
       try {
         await fs.promises.access(AGENTS_MD_PATH);
       } catch {
-        return res.json({ content: '', exists: false });
+        return res.json({ content: '', exists: false, path: AGENTS_MD_PATH });
       }
       const content = await fs.promises.readFile(AGENTS_MD_PATH, 'utf8');
-      return res.json({ content, exists: true });
+      return res.json({ content, exists: true, path: AGENTS_MD_PATH });
     } catch (error) {
       console.error('Failed to read AGENTS.md:', error);
       return res.status(500).json({ error: 'Failed to read AGENTS.md' });

package/server/lib/opencode/server-startup-runtime.js

@@ -138,7 +138,7 @@ export const createServerStartupRuntime = (dependencies) => {
       // Cover every signal a shell or dev harness may use to stop/restart us, so
       // the managed OpenCode child is always torn down gracefully instead of
       // orphaned: SIGINT/SIGQUIT (Ctrl+C/Ctrl+\), SIGTERM (kill/default), SIGHUP
-      // (terminal close), SIGUSR2 (nodemon restart for `dev:server:watch`).
+      // (terminal close), SIGUSR2 (nodemon restart outside Windows).
       process.on('SIGTERM', handleSignal);
       process.on('SIGINT', handleSignal);
       process.on('SIGQUIT', handleSignal);