@lowdefy/server-dev 6.1.0 → 7.1.0

package/manager/watchers/pluginSourceWatcher.mjs

@@ -0,0 +1,79 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import path from 'path';
+import createPluginSourceIgnore from './createPluginSourceIgnore.mjs';
+import listServerSidePackages from './listServerSidePackages.mjs';
+import readPluginDefinitions from '../utils/readPluginDefinitions.mjs';
+import selectLocalPluginPackages from './selectLocalPluginPackages.mjs';
+import setupWatcher from '../utils/setupWatcher.mjs';
+
+function isInside({ filePath, dir }) {
+  const relative = path.relative(dir, filePath);
+  return !relative.startsWith('..') && !path.isAbsolute(relative);
+}
+
+// A local plugin's code can change while the dev server runs, and nothing
+// else watches it when it lives outside the config directory. The config
+// build reads each plugin's type list, so any change rebuilds - which also
+// clears a build a broken plugin failed. The server process caches the
+// modules of server-side types (requests, connections, operators, ...), so a
+// change to a plugin that has them also restarts the server; client code
+// is Vite's to hot-replace. Only code files anywhere in the package are
+// watched: a plugin may be imported from its sources or from a build output
+// its own watcher writes, but non-code files (public/, YAML, Markdown) are
+// never plugin code, and a package that is also the config directory writes
+// some of them on every build (see createPluginSourceIgnore).
+async function pluginSourceWatcher(context) {
+  const plugins = await readPluginDefinitions({ directories: context.directories });
+  const packages = selectLocalPluginPackages({
+    directories: context.directories,
+    packageNames: plugins.map((plugin) => plugin.name),
+  });
+  if (packages.length === 0) {
+    return undefined;
+  }
+
+  const callback = async (filePaths) => {
+    const changedFiles = filePaths.flat();
+    const customTypesMap = JSON.parse(
+      fs.readFileSync(path.join(context.directories.build, 'customTypesMap.json'), 'utf8')
+    );
+    const serverSide = listServerSidePackages({ customTypesMap });
+    const restart = packages.some(
+      ({ package: packageName, dir }) =>
+        serverSide.has(packageName) && changedFiles.some((filePath) => isInside({ filePath, dir }))
+    );
+    context.logger.info({ spin: 'start' }, 'Local plugin source changed, rebuilding.');
+    try {
+      await context.lowdefyBuild();
+    } finally {
+      await context.syncServer({ restart });
+      await context.reloadClients();
+    }
+  };
+
+  return setupWatcher({
+    callback,
+    context,
+    onBusy: context.buildActivity.setBusy,
+    ignorePaths: [createPluginSourceIgnore({ directories: context.directories })],
+    watchPaths: packages.map(({ dir }) => dir),
+  });
+}
+
+export default pluginSourceWatcher;

package/manager/watchers/pluginSourceWatcher.test.mjs

@@ -0,0 +1,222 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { jest } from '@jest/globals';
+
+import flushFsEvents from '../../test-utils/flushFsEvents.mjs';
+import waitFor from '../../test-utils/waitFor.mjs';
+
+const { default: pluginSourceWatcher } = await import('./pluginSourceWatcher.mjs');
+
+// macOS can hold file events back for tens of seconds on a busy machine.
+jest.setTimeout(180000);
+
+let root;
+let context;
+let watcher;
+
+function writeCustomTypesMap(customTypesMap) {
+  fs.writeFileSync(
+    path.join(context.directories.build, 'customTypesMap.json'),
+    JSON.stringify(customTypesMap)
+  );
+}
+
+function writeLowdefyYaml(pluginNames) {
+  fs.writeFileSync(
+    path.join(context.directories.config, 'lowdefy.yaml'),
+    `lowdefy: local\nplugins:\n${pluginNames
+      .map((name) => `  - name: '${name}'\n    version: 'workspace:*'\n`)
+      .join('')}`
+  );
+}
+
+// Otherwise the fixture writes can reach the watcher as edits and rebuild
+// before the edit under test.
+async function startWatcher() {
+  await flushFsEvents();
+  watcher = await pluginSourceWatcher(context);
+}
+
+function addLinkedPackage(name) {
+  const dir = path.join(root, 'plugins', name);
+  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'dist'), { recursive: true });
+  const linked = path.join(context.directories.server, 'node_modules', name);
+  fs.mkdirSync(path.dirname(linked), { recursive: true });
+  fs.symlinkSync(dir, linked, 'dir');
+  return dir;
+}
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-plugin-watcher-test-'));
+  const config = path.join(root, 'app');
+  const server = path.join(config, '.lowdefy', 'dev');
+  fs.mkdirSync(path.join(server, 'node_modules'), { recursive: true });
+  fs.mkdirSync(path.join(server, 'build'), { recursive: true });
+  context = {
+    buildActivity: { setBusy: jest.fn() },
+    directories: { build: path.join(server, 'build'), config, server },
+    logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    lowdefyBuild: jest.fn(async () => {}),
+    reloadClients: jest.fn(async () => {}),
+    syncServer: jest.fn(async () => {}),
+  };
+  writeCustomTypesMap({});
+});
+
+afterEach(async () => {
+  if (watcher) {
+    await watcher.close();
+    watcher = undefined;
+  }
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('pluginSourceWatcher watches nothing when lowdefy.yaml lists no local plugin', async () => {
+  writeLowdefyYaml(['@lowdefy/blocks-basic']);
+
+  await expect(pluginSourceWatcher(context)).resolves.toBeUndefined();
+});
+
+test.each([
+  ['a server-side plugin rebuilds and restarts the server', 'requests', 'src/find.js', true],
+  ['a block-only plugin rebuilds without a restart', 'blocks', 'src/Fancy.js', false],
+  ['a plugin imported from its build output rebuilds', 'blocks', 'dist/Fancy.js', false],
+])('editing %s', async (_, kind, file, restart) => {
+  const dir = addLinkedPackage('@app/plugin');
+  fs.writeFileSync(path.join(dir, file), 'export default 1;');
+  writeLowdefyYaml(['@app/plugin']);
+  writeCustomTypesMap({ [kind]: { Type: { package: '@app/plugin', version: '1.0.0' } } });
+
+  await startWatcher();
+  fs.writeFileSync(path.join(dir, file), 'export default 2;');
+  await waitFor(() => context.reloadClients.mock.calls.length > 0, {
+    description: 'clients to reload',
+  });
+
+  expect(context.lowdefyBuild).toHaveBeenCalledTimes(1);
+  expect(context.syncServer).toHaveBeenCalledWith({ restart });
+  expect(context.buildActivity.setBusy.mock.calls[0]).toEqual([true]);
+});
+
+test('a fix to a plugin whose edit failed the build rebuilds again', async () => {
+  const dir = addLinkedPackage('@app/plugin');
+  fs.writeFileSync(path.join(dir, 'src', 'types.js'), 'export default {};');
+  writeLowdefyYaml(['@app/plugin']);
+  context.lowdefyBuild.mockRejectedValueOnce(new Error('Failed to import plugin "@app/plugin".'));
+
+  await startWatcher();
+  fs.writeFileSync(path.join(dir, 'src', 'types.js'), 'export default {;');
+  await waitFor(() => context.syncServer.mock.calls.length === 1, {
+    description: 'the failed build to sync the server',
+  });
+  fs.writeFileSync(path.join(dir, 'src', 'types.js'), 'export default { blocks: [] };');
+  await waitFor(() => context.syncServer.mock.calls.length === 2, {
+    description: 'the fixed build to sync the server',
+  });
+
+  expect(context.lowdefyBuild).toHaveBeenCalledTimes(2);
+});
+
+function linkConfigAsPackage(name) {
+  const dir = context.directories.config;
+  fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'dist'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'public', 'md'), { recursive: true });
+  fs.mkdirSync(path.join(dir, 'pages'), { recursive: true });
+  const linked = path.join(context.directories.server, 'node_modules', name);
+  fs.mkdirSync(path.dirname(linked), { recursive: true });
+  fs.symlinkSync(dir, linked, 'dir');
+  return dir;
+}
+
+// Gives chokidar time to report an event the watcher should ignore, then
+// checks no build ran: a build would have started within the batch delay.
+async function expectNoRebuild() {
+  await new Promise((resolve) => setTimeout(resolve, 1200));
+  expect(context.lowdefyBuild).not.toHaveBeenCalled();
+}
+
+describe('a plugin package that is also the config directory', () => {
+  // Only non-code files are written before the watcher starts: macOS can
+  // report a write made just before the watch began, which for a code file
+  // would rebuild and spoil a test that expects none.
+  beforeEach(() => {
+    const dir = linkConfigAsPackage('@app/docs');
+    fs.writeFileSync(path.join(dir, 'public', 'llms.txt'), 'one');
+    fs.writeFileSync(path.join(dir, 'public', 'search-index.json'), '[]');
+    fs.writeFileSync(path.join(dir, 'public', 'md', 'page.md'), 'one');
+    fs.writeFileSync(path.join(dir, 'pages', 'home.yaml'), 'id: home');
+    fs.writeFileSync(path.join(dir, 'pages', 'home.md'), 'one');
+    writeLowdefyYaml(['@app/docs']);
+  });
+
+  test.each([['public/llms.txt'], ['public/search-index.json'], ['public/md/page.md']])(
+    'writing %s does not rebuild',
+    async (file) => {
+      await startWatcher();
+      fs.writeFileSync(path.join(context.directories.config, file), 'two');
+      await expectNoRebuild();
+    }
+  );
+
+  test.each([['pages/home.yaml'], ['pages/home.md']])(
+    'editing %s does not rebuild',
+    async (file) => {
+      await startWatcher();
+      fs.writeFileSync(path.join(context.directories.config, file), 'two');
+      await expectNoRebuild();
+    }
+  );
+
+  test('writing into the build directory does not rebuild', async () => {
+    await startWatcher();
+    fs.writeFileSync(path.join(context.directories.build, 'keyMap.json'), '{}');
+    await expectNoRebuild();
+  });
+
+  test.each([['src/types.js'], ['dist/types.js']])('editing %s rebuilds', async (file) => {
+    await startWatcher();
+    fs.writeFileSync(path.join(context.directories.config, file), 'export default 2;');
+    await waitFor(() => context.reloadClients.mock.calls.length > 0);
+    expect(context.lowdefyBuild).toHaveBeenCalledTimes(1);
+  });
+});
+
+test.each([
+  ['a .js file rebuilds', 'src/other.js', true],
+  ['a .json file rebuilds', 'package.json', true],
+  ['a .md file does not rebuild', 'README.md', false],
+  ['a .yaml file does not rebuild', 'src/config.yaml', false],
+  ['a file with no extension does not rebuild', 'LICENSE', false],
+])('in a plugin outside the config directory, %s', async (_, file, rebuilds) => {
+  const dir = addLinkedPackage('@app/plugin');
+  fs.writeFileSync(path.join(dir, file), 'one');
+  writeLowdefyYaml(['@app/plugin']);
+
+  await startWatcher();
+  fs.writeFileSync(path.join(dir, file), 'two');
+  if (rebuilds) {
+    await waitFor(() => context.reloadClients.mock.calls.length > 0);
+    expect(context.lowdefyBuild).toHaveBeenCalledTimes(1);
+    return;
+  }
+  await expectNoRebuild();
+});

package/manager/watchers/restartRequestWatcher.mjs

@@ -0,0 +1,71 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import path from 'path';
+import { type } from '@lowdefy/helpers';
+import setupWatcher from '../utils/setupWatcher.mjs';
+
+function readReason(filePath) {
+  try {
+    const { reason } = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+    return type.isString(reason) && reason !== '' ? reason : 'no reason given';
+  } catch {
+    // The app may still be writing the file, or it was already consumed.
+    return 'no reason given';
+  }
+}
+
+// The dev tools (POST /lowdefy-docs/restart, lowdefy_restart) run inside the
+// app process, which has no channel to the manager except the build directory.
+// They write build/.restart; the manager consumes it here.
+function restartRequestWatcher(context) {
+  const sentinelPath = path.join(context.directories.build, '.restart');
+
+  const callback = async () => {
+    if (!fs.existsSync(sentinelPath)) {
+      return;
+    }
+    const reason = readReason(sentinelPath);
+    fs.rmSync(sentinelPath, { force: true });
+    context.logger.info({ spin: 'start' }, `Restart requested by the dev tools: ${reason}.`);
+    // The config build reads the plugins' type lists afresh, so a block,
+    // request or operator type added to a plugin since the last build is
+    // defined once the server is back. The server restarts even when the
+    // build fails.
+    try {
+      await context.lowdefyBuild();
+    } finally {
+      await context.syncServer({ restart: true });
+    }
+  };
+
+  // The sentinel does not exist until the first request, so watch the build
+  // directory (non-recursively) and react only to the sentinel itself.
+  return setupWatcher({
+    callback,
+    context,
+    onBusy: context.buildActivity.setBusy,
+    watchDotfiles: true,
+    watchPaths: [context.directories.build],
+    ignorePaths: [
+      (filePath) => filePath !== context.directories.build && filePath !== sentinelPath,
+    ],
+    delay: 100,
+  });
+}
+
+export default restartRequestWatcher;

package/manager/watchers/restartRequestWatcher.test.mjs

@@ -0,0 +1,111 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { jest } from '@jest/globals';
+
+import flushFsEvents from '../../test-utils/flushFsEvents.mjs';
+import waitFor from '../../test-utils/waitFor.mjs';
+
+const { default: restartRequestWatcher } = await import('./restartRequestWatcher.mjs');
+
+// macOS can hold file events back for tens of seconds on a busy machine.
+jest.setTimeout(180000);
+
+let fixtureDir;
+let context;
+let watcher;
+
+beforeEach(async () => {
+  fixtureDir = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-restart-watcher-test-'));
+  fs.mkdirSync(path.join(fixtureDir, 'build'), { recursive: true });
+  await flushFsEvents();
+  context = {
+    directories: { build: path.join(fixtureDir, 'build') },
+    logger: { info: jest.fn(), warn: jest.fn(), error: jest.fn() },
+    buildActivity: { setBusy: jest.fn() },
+    lowdefyBuild: jest.fn(async () => {}),
+    syncServer: jest.fn(async () => {}),
+  };
+});
+
+afterEach(async () => {
+  if (watcher) {
+    await watcher.close();
+    watcher = undefined;
+  }
+  fs.rmSync(fixtureDir, { recursive: true, force: true });
+});
+
+test('writing build/.restart restarts the server once and removes the sentinel', async () => {
+  watcher = await restartRequestWatcher(context);
+  const sentinelPath = path.join(fixtureDir, 'build', '.restart');
+
+  fs.writeFileSync(
+    sentinelPath,
+    JSON.stringify({ requestedAt: new Date().toISOString(), reason: 'Edited a request plugin' })
+  );
+  await waitFor(() => context.syncServer.mock.calls.length > 0, {
+    description: 'the server restart',
+  });
+  expect(fs.existsSync(sentinelPath)).toBe(false);
+
+  // Removing the sentinel is itself a file event. A second request, seen
+  // after it, fences it: any restart the removal caused lands before the
+  // second request's.
+  fs.writeFileSync(sentinelPath, JSON.stringify({ reason: 'Fence' }));
+  await waitFor(() => context.syncServer.mock.calls.length > 1, {
+    description: 'the second restart',
+  });
+
+  expect(context.syncServer).toHaveBeenCalledTimes(2);
+  expect(
+    context.logger.info.mock.calls.filter(([, message]) => message.startsWith('Restart requested'))
+  ).toEqual([
+    [{ spin: 'start' }, 'Restart requested by the dev tools: Edited a request plugin.'],
+    [{ spin: 'start' }, 'Restart requested by the dev tools: Fence.'],
+  ]);
+});
+
+test('a restart request rebuilds the config before restarting the server', async () => {
+  watcher = await restartRequestWatcher(context);
+  const sentinelPath = path.join(fixtureDir, 'build', '.restart');
+
+  fs.writeFileSync(sentinelPath, JSON.stringify({ reason: 'Added a block type' }));
+  await waitFor(() => context.syncServer.mock.calls.length > 0, {
+    description: 'the server restart',
+  });
+
+  expect(context.lowdefyBuild).toHaveBeenCalledTimes(1);
+  expect(context.lowdefyBuild.mock.invocationCallOrder[0]).toBeLessThan(
+    context.syncServer.mock.invocationCallOrder[0]
+  );
+});
+
+test('a restart request restarts the server when the config build fails', async () => {
+  context.lowdefyBuild.mockRejectedValue(new Error('Build failed with 1 error(s).'));
+  watcher = await restartRequestWatcher(context);
+  const sentinelPath = path.join(fixtureDir, 'build', '.restart');
+
+  fs.writeFileSync(sentinelPath, JSON.stringify({ reason: 'Added a block type' }));
+  await waitFor(() => context.syncServer.mock.calls.length > 0, {
+    description: 'the server restart',
+  });
+
+  expect(context.syncServer).toHaveBeenCalledTimes(1);
+});

package/manager/watchers/selectLocalPluginPackages.mjs

@@ -0,0 +1,48 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import path from 'path';
+
+// The build imports plugins from the server directory; an app in a pnpm
+// workspace also links them into its own node_modules. A published package
+// lives inside node_modules and cannot change under a running dev server;
+// only a linked local plugin resolves outside it.
+function resolveLocalPluginDir({ directories, packageName }) {
+  for (const base of [directories.server, directories.config]) {
+    const linked = path.join(base, 'node_modules', packageName);
+    if (fs.existsSync(linked)) {
+      const realPath = fs.realpathSync(linked);
+      return realPath.split(path.sep).includes('node_modules') ? null : realPath;
+    }
+  }
+  return null;
+}
+
+// The plugins lowdefy.yaml lists that are local packages, whatever kinds of
+// types they hold: a block-only plugin's type list is read by the config
+// build too, so an edit to it - or a fix to one that broke the build - must
+// rebuild.
+function selectLocalPluginPackages({ directories, packageNames }) {
+  return [...new Set(packageNames)]
+    .map((packageName) => ({
+      package: packageName,
+      dir: resolveLocalPluginDir({ directories, packageName }),
+    }))
+    .filter(({ dir }) => dir !== null);
+}
+
+export default selectLocalPluginPackages;

package/manager/watchers/selectLocalPluginPackages.test.mjs

@@ -0,0 +1,73 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+
+import selectLocalPluginPackages from './selectLocalPluginPackages.mjs';
+
+let root;
+let directories;
+
+function addLinkedPackage({ name, base }) {
+  const dir = path.join(root, 'plugins', name);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(path.dirname(path.join(base, 'node_modules', name)), { recursive: true });
+  fs.symlinkSync(dir, path.join(base, 'node_modules', name), 'dir');
+  return fs.realpathSync(dir);
+}
+
+beforeEach(() => {
+  root = fs.mkdtempSync(path.join(os.tmpdir(), 'lowdefy-plugin-select-test-'));
+  directories = {
+    config: path.join(root, 'app'),
+    server: path.join(root, 'app', '.lowdefy', 'dev'),
+  };
+  fs.mkdirSync(path.join(directories.server, 'node_modules'), { recursive: true });
+});
+
+afterEach(() => {
+  fs.rmSync(root, { recursive: true, force: true });
+});
+
+test('selectLocalPluginPackages selects every linked plugin, block-only plugins included', () => {
+  const ui = addLinkedPackage({ name: '@app/ui-plugin', base: directories.server });
+  const db = addLinkedPackage({ name: '@app/db-plugin', base: directories.config });
+
+  expect(
+    selectLocalPluginPackages({
+      directories,
+      packageNames: ['@app/ui-plugin', '@app/db-plugin', '@app/ui-plugin'],
+    })
+  ).toEqual([
+    { package: '@app/ui-plugin', dir: ui },
+    { package: '@app/db-plugin', dir: db },
+  ]);
+});
+
+test('selectLocalPluginPackages skips installed and missing packages', () => {
+  fs.mkdirSync(path.join(directories.server, 'node_modules', '@lowdefy', 'connection-mongodb'), {
+    recursive: true,
+  });
+
+  expect(
+    selectLocalPluginPackages({
+      directories,
+      packageNames: ['@lowdefy/connection-mongodb', '@app/not-installed'],
+    })
+  ).toEqual([]);
+});

package/manager/watchers/serverPackageWatcher.mjs

@@ -0,0 +1,38 @@
+/*
+  Copyright 2020-2026 Lowdefy, Inc
+
+  Licensed under the Apache License, Version 2.0 (the "License");
+  you may not use this file except in compliance with the License.
+  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+*/
+
+import path from 'path';
+import setupWatcher from '../utils/setupWatcher.mjs';
+
+// A page build in the dev server that finds a plugin package missing adds it
+// to the server's package.json (the page answers "installing"). Installing it,
+// rebuilding and restarting is syncServer's work, as it is after a config
+// build that adds one. Config builds sync the server themselves, so this
+// watcher only has work when the change came from the dev server.
+function serverPackageWatcher(context) {
+  const callback = async () => {
+    await context.syncServer();
+  };
+  return setupWatcher({
+    callback,
+    context,
+    onBusy: context.buildActivity.setBusy,
+    watchDotfiles: true,
+    watchPaths: [path.join(context.directories.server, 'package.json')],
+  });
+}
+
+export default serverPackageWatcher;