wind-agent-cli 1.37.2 → 1.38.0

package/server/modules/plugins/plugins.module.ts

@@ -1,33 +1,33 @@
-import fs from 'node:fs';
-import path from 'node:path';
-
-import mime from 'mime-types';
-
-import {
-  getPluginDir, getPluginsConfig, getPluginsDir, installPluginFromGit,
-  resolvePluginAssetPath, savePluginsConfig, scanPlugins, uninstallPlugin, updatePluginFromGit,
-} from './plugin-registry.service.js';
-import {
-  getPluginPort, isPluginRunning, startPluginServer, stopPluginServer,
-} from './plugin-process.service.js';
-import { createPluginsRouter } from './plugins.routes.js';
-import { createPluginsService } from './plugins.service.js';
-
-const pluginsService = createPluginsService({
-  scanPlugins, readConfig: getPluginsConfig, saveConfig: savePluginsConfig,
-  getPluginDirectory: getPluginDir, getPluginsDirectory: getPluginsDir,
-  resolveAsset: resolvePluginAssetPath,
-  assetIsFile: (assetPath) => { try { return fs.statSync(assetPath).isFile(); } catch { return false; } },
-  contentType: (assetPath) => mime.lookup(assetPath) || 'application/octet-stream',
-  install: installPluginFromGit,
-  update: updatePluginFromGit,
-  uninstall: async (pluginName) => { await uninstallPlugin(pluginName); },
-  startServer: startPluginServer,
-  stopServer: async (pluginName) => { await stopPluginServer(pluginName); },
-  getServerPort: getPluginPort, isServerRunning: isPluginRunning,
-  joinPath: path.join,
-  logError: (message, error) => console.error(message, error),
-});
-
-/** Plugin router assembled with filesystem, loader, and process adapters. */
-export const pluginsRoutes = createPluginsRouter(pluginsService);
+import fs from 'node:fs';
+import path from 'node:path';
+
+import mime from 'mime-types';
+
+import {
+  getPluginDir, getPluginsConfig, getPluginsDir, installPluginFromGit,
+  resolvePluginAssetPath, savePluginsConfig, scanPlugins, uninstallPlugin, updatePluginFromGit,
+} from './plugin-registry.service.js';
+import {
+  getPluginPort, isPluginRunning, startPluginServer, stopPluginServer,
+} from './plugin-process.service.js';
+import { createPluginsRouter } from './plugins.routes.js';
+import { createPluginsService } from './plugins.service.js';
+
+const pluginsService = createPluginsService({
+  scanPlugins, readConfig: getPluginsConfig, saveConfig: savePluginsConfig,
+  getPluginDirectory: getPluginDir, getPluginsDirectory: getPluginsDir,
+  resolveAsset: resolvePluginAssetPath,
+  assetIsFile: (assetPath) => { try { return fs.statSync(assetPath).isFile(); } catch { return false; } },
+  contentType: (assetPath) => mime.lookup(assetPath) || 'application/octet-stream',
+  install: installPluginFromGit,
+  update: updatePluginFromGit,
+  uninstall: async (pluginName) => { await uninstallPlugin(pluginName); },
+  startServer: startPluginServer,
+  stopServer: async (pluginName) => { await stopPluginServer(pluginName); },
+  getServerPort: getPluginPort, isServerRunning: isPluginRunning,
+  joinPath: path.join,
+  logError: (message, error) => console.error(message, error),
+});
+
+/** Plugin router assembled with filesystem, loader, and process adapters. */
+export const pluginsRoutes = createPluginsRouter(pluginsService);

package/server/modules/plugins/plugins.routes.ts

@@ -1,66 +1,66 @@
-import fs from 'node:fs';
-import http from 'node:http';
-
-import express from 'express';
-
-import type { createPluginsService } from './plugins.service.js';
-
-function wildcardPath(req: express.Request): string {
-  return ((req.params as Record<string, string>)['0'] ?? '').trim();
-}
-
-function routeParameter(value: string | string[]): string {
-  return Array.isArray(value) ? value[0] ?? '' : value;
-}
-
-/** Creates plugin routes; transport streaming remains here while decisions live in the service. */
-export function createPluginsRouter(service: ReturnType<typeof createPluginsService>): express.Router {
-  const router = express.Router();
-  const respond = (operation: (req: express.Request) => unknown | Promise<unknown>) =>
-    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
-      try { res.json(await operation(req)); } catch (error) { next(error); }
-    };
-
-  router.get('/', respond(() => service.list()));
-  router.get('/:name/manifest', respond((req) => service.getManifest(routeParameter(req.params.name))));
-  router.get('/:name/assets/*', async (req, res, next) => {
-    try {
-      const asset = service.resolveAsset(routeParameter(req.params.name), wildcardPath(req));
-      res.setHeader('Content-Type', asset.contentType);
-      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
-      const stream = fs.createReadStream(asset.path);
-      stream.on('error', next);
-      stream.pipe(res);
-    } catch (error) { next(error); }
-  });
-  router.put('/:name/enable', respond((req) => service.setEnabled(routeParameter(req.params.name), req.body?.enabled)));
-  router.post('/install', respond((req) => service.install(req.body?.url)));
-  router.post('/:name/update', respond((req) => service.update(routeParameter(req.params.name))));
-  router.all('/:name/rpc/*', async (req, res, next) => {
-    try {
-      const { port, secrets } = await service.prepareRpc(routeParameter(req.params.name));
-      const headers: Record<string, string> = {
-        'content-type': String(req.headers['content-type'] ?? 'application/json'),
-      };
-      for (const [key, value] of Object.entries(secrets)) {
-        headers[`x-plugin-secret-${key.toLowerCase()}`] = String(value);
-      }
-      const query = req.url.includes('?') ? `?${req.url.split('?').slice(1).join('?')}` : '';
-      const proxyRequest = http.request({
-        hostname: '127.0.0.1', port, path: `/${wildcardPath(req)}${query}`, method: req.method, headers,
-      }, (proxyResponse) => {
-        res.writeHead(proxyResponse.statusCode ?? 502, proxyResponse.headers);
-        proxyResponse.pipe(res);
-      });
-      proxyRequest.on('error', next);
-      if (req.headers['content-length'] && req.body !== undefined) {
-        const body = JSON.stringify(req.body);
-        proxyRequest.setHeader('content-length', Buffer.byteLength(body));
-        proxyRequest.write(body);
-      }
-      proxyRequest.end();
-    } catch (error) { next(error); }
-  });
-  router.delete('/:name', respond((req) => service.uninstall(routeParameter(req.params.name))));
-  return router;
-}
+import fs from 'node:fs';
+import http from 'node:http';
+
+import express from 'express';
+
+import type { createPluginsService } from './plugins.service.js';
+
+function wildcardPath(req: express.Request): string {
+  return ((req.params as Record<string, string>)['0'] ?? '').trim();
+}
+
+function routeParameter(value: string | string[]): string {
+  return Array.isArray(value) ? value[0] ?? '' : value;
+}
+
+/** Creates plugin routes; transport streaming remains here while decisions live in the service. */
+export function createPluginsRouter(service: ReturnType<typeof createPluginsService>): express.Router {
+  const router = express.Router();
+  const respond = (operation: (req: express.Request) => unknown | Promise<unknown>) =>
+    async (req: express.Request, res: express.Response, next: express.NextFunction) => {
+      try { res.json(await operation(req)); } catch (error) { next(error); }
+    };
+
+  router.get('/', respond(() => service.list()));
+  router.get('/:name/manifest', respond((req) => service.getManifest(routeParameter(req.params.name))));
+  router.get('/:name/assets/*', async (req, res, next) => {
+    try {
+      const asset = service.resolveAsset(routeParameter(req.params.name), wildcardPath(req));
+      res.setHeader('Content-Type', asset.contentType);
+      res.setHeader('Cache-Control', 'no-store, no-cache, must-revalidate');
+      const stream = fs.createReadStream(asset.path);
+      stream.on('error', next);
+      stream.pipe(res);
+    } catch (error) { next(error); }
+  });
+  router.put('/:name/enable', respond((req) => service.setEnabled(routeParameter(req.params.name), req.body?.enabled)));
+  router.post('/install', respond((req) => service.install(req.body?.url)));
+  router.post('/:name/update', respond((req) => service.update(routeParameter(req.params.name))));
+  router.all('/:name/rpc/*', async (req, res, next) => {
+    try {
+      const { port, secrets } = await service.prepareRpc(routeParameter(req.params.name));
+      const headers: Record<string, string> = {
+        'content-type': String(req.headers['content-type'] ?? 'application/json'),
+      };
+      for (const [key, value] of Object.entries(secrets)) {
+        headers[`x-plugin-secret-${key.toLowerCase()}`] = String(value);
+      }
+      const query = req.url.includes('?') ? `?${req.url.split('?').slice(1).join('?')}` : '';
+      const proxyRequest = http.request({
+        hostname: '127.0.0.1', port, path: `/${wildcardPath(req)}${query}`, method: req.method, headers,
+      }, (proxyResponse) => {
+        res.writeHead(proxyResponse.statusCode ?? 502, proxyResponse.headers);
+        proxyResponse.pipe(res);
+      });
+      proxyRequest.on('error', next);
+      if (req.headers['content-length'] && req.body !== undefined) {
+        const body = JSON.stringify(req.body);
+        proxyRequest.setHeader('content-length', Buffer.byteLength(body));
+        proxyRequest.write(body);
+      }
+      proxyRequest.end();
+    } catch (error) { next(error); }
+  });
+  router.delete('/:name', respond((req) => service.uninstall(routeParameter(req.params.name))));
+  return router;
+}

package/server/modules/plugins/plugins.service.ts

@@ -1,147 +1,147 @@
-import { AppError } from '@/shared/utils.js';
-
-type PluginManifest = Record<string, unknown> & {
-  name: string;
-  dirName?: string;
-  enabled?: boolean;
-  server?: unknown;
-};
-
-type PluginConfig = Record<string, { enabled?: boolean; secrets?: Record<string, unknown> }>;
-
-type PluginDependencies = {
-  scanPlugins(): PluginManifest[];
-  readConfig(): PluginConfig;
-  saveConfig(config: PluginConfig): void;
-  getPluginDirectory(pluginName: string): string | null;
-  getPluginsDirectory(): string;
-  resolveAsset(pluginName: string, assetPath: string): string | null;
-  assetIsFile(assetPath: string): boolean;
-  contentType(assetPath: string): string;
-  install(url: string): Promise<unknown>;
-  update(pluginName: string): Promise<unknown>;
-  uninstall(pluginName: string): Promise<unknown>;
-  startServer(pluginName: string, pluginDirectory: string, serverConfig: unknown): Promise<number>;
-  stopServer(pluginName: string): Promise<void>;
-  getServerPort(pluginName: string): number | undefined;
-  isServerRunning(pluginName: string): boolean;
-  joinPath(...parts: string[]): string;
-  logError(message: string, error: unknown): void;
-};
-
-function validatePluginName(pluginName: string): void {
-  if (!/^[a-zA-Z0-9_-]+$/.test(pluginName)) {
-    throw new AppError('Invalid plugin name', { code: 'INVALID_PLUGIN_NAME', statusCode: 400 });
-  }
-}
-
-function normalizePluginManifest(value: unknown): PluginManifest {
-  if (typeof value !== 'object' || value === null) {
-    throw new AppError('Plugin manifest is invalid', {
-      code: 'INVALID_PLUGIN_MANIFEST',
-      statusCode: 400,
-    });
-  }
-  const manifest = value as Record<string, unknown>;
-  if (typeof manifest.name !== 'string') {
-    throw new AppError('Plugin manifest is missing its name', {
-      code: 'INVALID_PLUGIN_MANIFEST',
-      statusCode: 400,
-    });
-  }
-  return manifest as PluginManifest;
-}
-
-/** Creates plugin-management workflows around loader and process adapters. */
-export function createPluginsService(dependencies: PluginDependencies) {
-  async function startServerIfAvailable(plugin: PluginManifest): Promise<void> {
-    if (!plugin.server || dependencies.isServerRunning(plugin.name)) return;
-    const pluginDirectory = dependencies.getPluginDirectory(plugin.name);
-    if (!pluginDirectory) return;
-    try {
-      await dependencies.startServer(plugin.name, pluginDirectory, plugin.server);
-    } catch (error) {
-      dependencies.logError(`Failed to start plugin server for ${plugin.name}`, error);
-    }
-  }
-
-  return {
-    list() {
-      return {
-        plugins: dependencies.scanPlugins().map((plugin) => ({
-          ...plugin,
-          serverRunning: plugin.server ? dependencies.isServerRunning(plugin.name) : false,
-        })),
-      };
-    },
-    getManifest(pluginName: string) {
-      validatePluginName(pluginName);
-      const plugin = dependencies.scanPlugins().find((candidate) => candidate.name === pluginName);
-      if (!plugin) throw new AppError('Plugin not found', { code: 'PLUGIN_NOT_FOUND', statusCode: 404 });
-      return plugin;
-    },
-    resolveAsset(pluginName: string, assetPath: string) {
-      validatePluginName(pluginName);
-      if (!assetPath) throw new AppError('No asset path specified', { code: 'PLUGIN_ASSET_REQUIRED', statusCode: 400 });
-      const resolvedPath = dependencies.resolveAsset(pluginName, assetPath);
-      if (!resolvedPath || !dependencies.assetIsFile(resolvedPath)) {
-        throw new AppError('Asset not found', { code: 'PLUGIN_ASSET_NOT_FOUND', statusCode: 404 });
-      }
-      return { path: resolvedPath, contentType: dependencies.contentType(resolvedPath) };
-    },
-    async setEnabled(pluginName: string, enabled: unknown) {
-      validatePluginName(pluginName);
-      if (typeof enabled !== 'boolean') {
-        throw new AppError('"enabled" must be a boolean', { code: 'INVALID_PLUGIN_ENABLED', statusCode: 400 });
-      }
-      const plugin = this.getManifest(pluginName);
-      const config = dependencies.readConfig();
-      config[pluginName] = { ...config[pluginName], enabled };
-      dependencies.saveConfig(config);
-      if (plugin.server && enabled) await startServerIfAvailable(plugin);
-      if (plugin.server && !enabled && dependencies.isServerRunning(pluginName)) {
-        await dependencies.stopServer(pluginName);
-      }
-      return { success: true, name: pluginName, enabled };
-    },
-    async install(urlInput: unknown) {
-      const url = typeof urlInput === 'string' ? urlInput.trim() : '';
-      if (!url || (!url.startsWith('https://') && !url.startsWith('git@'))) {
-        throw new AppError('URL must start with https:// or git@', { code: 'INVALID_PLUGIN_URL', statusCode: 400 });
-      }
-      const plugin = normalizePluginManifest(await dependencies.install(url));
-      await startServerIfAvailable(plugin);
-      return { success: true, plugin };
-    },
-    async update(pluginName: string) {
-      validatePluginName(pluginName);
-      const wasRunning = dependencies.isServerRunning(pluginName);
-      if (wasRunning) await dependencies.stopServer(pluginName);
-      const plugin = normalizePluginManifest(await dependencies.update(pluginName));
-      if (wasRunning) await startServerIfAvailable(plugin);
-      return { success: true, plugin };
-    },
-    async prepareRpc(pluginName: string) {
-      validatePluginName(pluginName);
-      let port = dependencies.getServerPort(pluginName);
-      if (!port) {
-        const plugin = this.getManifest(pluginName);
-        if (!plugin.server) throw new AppError('Plugin server is not running', { code: 'PLUGIN_SERVER_UNAVAILABLE', statusCode: 503 });
-        if (!plugin.enabled) throw new AppError('Plugin is disabled', { code: 'PLUGIN_DISABLED', statusCode: 503 });
-        const pluginDirectory = dependencies.joinPath(
-          dependencies.getPluginsDirectory(),
-          plugin.dirName ?? plugin.name,
-        );
-        port = await dependencies.startServer(pluginName, pluginDirectory, plugin.server);
-      }
-      const secrets = dependencies.readConfig()[pluginName]?.secrets ?? {};
-      return { port, secrets };
-    },
-    async uninstall(pluginName: string) {
-      validatePluginName(pluginName);
-      if (dependencies.isServerRunning(pluginName)) await dependencies.stopServer(pluginName);
-      await dependencies.uninstall(pluginName);
-      return { success: true, name: pluginName };
-    },
-  };
-}
+import { AppError } from '@/shared/utils.js';
+
+type PluginManifest = Record<string, unknown> & {
+  name: string;
+  dirName?: string;
+  enabled?: boolean;
+  server?: unknown;
+};
+
+type PluginConfig = Record<string, { enabled?: boolean; secrets?: Record<string, unknown> }>;
+
+type PluginDependencies = {
+  scanPlugins(): PluginManifest[];
+  readConfig(): PluginConfig;
+  saveConfig(config: PluginConfig): void;
+  getPluginDirectory(pluginName: string): string | null;
+  getPluginsDirectory(): string;
+  resolveAsset(pluginName: string, assetPath: string): string | null;
+  assetIsFile(assetPath: string): boolean;
+  contentType(assetPath: string): string;
+  install(url: string): Promise<unknown>;
+  update(pluginName: string): Promise<unknown>;
+  uninstall(pluginName: string): Promise<unknown>;
+  startServer(pluginName: string, pluginDirectory: string, serverConfig: unknown): Promise<number>;
+  stopServer(pluginName: string): Promise<void>;
+  getServerPort(pluginName: string): number | undefined;
+  isServerRunning(pluginName: string): boolean;
+  joinPath(...parts: string[]): string;
+  logError(message: string, error: unknown): void;
+};
+
+function validatePluginName(pluginName: string): void {
+  if (!/^[a-zA-Z0-9_-]+$/.test(pluginName)) {
+    throw new AppError('Invalid plugin name', { code: 'INVALID_PLUGIN_NAME', statusCode: 400 });
+  }
+}
+
+function normalizePluginManifest(value: unknown): PluginManifest {
+  if (typeof value !== 'object' || value === null) {
+    throw new AppError('Plugin manifest is invalid', {
+      code: 'INVALID_PLUGIN_MANIFEST',
+      statusCode: 400,
+    });
+  }
+  const manifest = value as Record<string, unknown>;
+  if (typeof manifest.name !== 'string') {
+    throw new AppError('Plugin manifest is missing its name', {
+      code: 'INVALID_PLUGIN_MANIFEST',
+      statusCode: 400,
+    });
+  }
+  return manifest as PluginManifest;
+}
+
+/** Creates plugin-management workflows around loader and process adapters. */
+export function createPluginsService(dependencies: PluginDependencies) {
+  async function startServerIfAvailable(plugin: PluginManifest): Promise<void> {
+    if (!plugin.server || dependencies.isServerRunning(plugin.name)) return;
+    const pluginDirectory = dependencies.getPluginDirectory(plugin.name);
+    if (!pluginDirectory) return;
+    try {
+      await dependencies.startServer(plugin.name, pluginDirectory, plugin.server);
+    } catch (error) {
+      dependencies.logError(`Failed to start plugin server for ${plugin.name}`, error);
+    }
+  }
+
+  return {
+    list() {
+      return {
+        plugins: dependencies.scanPlugins().map((plugin) => ({
+          ...plugin,
+          serverRunning: plugin.server ? dependencies.isServerRunning(plugin.name) : false,
+        })),
+      };
+    },
+    getManifest(pluginName: string) {
+      validatePluginName(pluginName);
+      const plugin = dependencies.scanPlugins().find((candidate) => candidate.name === pluginName);
+      if (!plugin) throw new AppError('Plugin not found', { code: 'PLUGIN_NOT_FOUND', statusCode: 404 });
+      return plugin;
+    },
+    resolveAsset(pluginName: string, assetPath: string) {
+      validatePluginName(pluginName);
+      if (!assetPath) throw new AppError('No asset path specified', { code: 'PLUGIN_ASSET_REQUIRED', statusCode: 400 });
+      const resolvedPath = dependencies.resolveAsset(pluginName, assetPath);
+      if (!resolvedPath || !dependencies.assetIsFile(resolvedPath)) {
+        throw new AppError('Asset not found', { code: 'PLUGIN_ASSET_NOT_FOUND', statusCode: 404 });
+      }
+      return { path: resolvedPath, contentType: dependencies.contentType(resolvedPath) };
+    },
+    async setEnabled(pluginName: string, enabled: unknown) {
+      validatePluginName(pluginName);
+      if (typeof enabled !== 'boolean') {
+        throw new AppError('"enabled" must be a boolean', { code: 'INVALID_PLUGIN_ENABLED', statusCode: 400 });
+      }
+      const plugin = this.getManifest(pluginName);
+      const config = dependencies.readConfig();
+      config[pluginName] = { ...config[pluginName], enabled };
+      dependencies.saveConfig(config);
+      if (plugin.server && enabled) await startServerIfAvailable(plugin);
+      if (plugin.server && !enabled && dependencies.isServerRunning(pluginName)) {
+        await dependencies.stopServer(pluginName);
+      }
+      return { success: true, name: pluginName, enabled };
+    },
+    async install(urlInput: unknown) {
+      const url = typeof urlInput === 'string' ? urlInput.trim() : '';
+      if (!url || (!url.startsWith('https://') && !url.startsWith('git@'))) {
+        throw new AppError('URL must start with https:// or git@', { code: 'INVALID_PLUGIN_URL', statusCode: 400 });
+      }
+      const plugin = normalizePluginManifest(await dependencies.install(url));
+      await startServerIfAvailable(plugin);
+      return { success: true, plugin };
+    },
+    async update(pluginName: string) {
+      validatePluginName(pluginName);
+      const wasRunning = dependencies.isServerRunning(pluginName);
+      if (wasRunning) await dependencies.stopServer(pluginName);
+      const plugin = normalizePluginManifest(await dependencies.update(pluginName));
+      if (wasRunning) await startServerIfAvailable(plugin);
+      return { success: true, plugin };
+    },
+    async prepareRpc(pluginName: string) {
+      validatePluginName(pluginName);
+      let port = dependencies.getServerPort(pluginName);
+      if (!port) {
+        const plugin = this.getManifest(pluginName);
+        if (!plugin.server) throw new AppError('Plugin server is not running', { code: 'PLUGIN_SERVER_UNAVAILABLE', statusCode: 503 });
+        if (!plugin.enabled) throw new AppError('Plugin is disabled', { code: 'PLUGIN_DISABLED', statusCode: 503 });
+        const pluginDirectory = dependencies.joinPath(
+          dependencies.getPluginsDirectory(),
+          plugin.dirName ?? plugin.name,
+        );
+        port = await dependencies.startServer(pluginName, pluginDirectory, plugin.server);
+      }
+      const secrets = dependencies.readConfig()[pluginName]?.secrets ?? {};
+      return { port, secrets };
+    },
+    async uninstall(pluginName: string) {
+      validatePluginName(pluginName);
+      if (dependencies.isServerRunning(pluginName)) await dependencies.stopServer(pluginName);
+      await dependencies.uninstall(pluginName);
+      return { success: true, name: pluginName };
+    },
+  };
+}

package/server/modules/plugins/tests/plugins.service.test.ts

@@ -1,32 +1,32 @@
-import assert from 'node:assert/strict';
-import test from 'node:test';
-
-import { createPluginsService } from '../plugins.service.js';
-
-type Dependencies = Parameters<typeof createPluginsService>[0];
-
-function dependencies(overrides: Partial<Dependencies> = {}): Dependencies {
-  return {
-    scanPlugins: () => [], readConfig: () => ({}), saveConfig: () => undefined,
-    getPluginDirectory: () => null, getPluginsDirectory: () => '/plugins',
-    resolveAsset: () => null, assetIsFile: () => false, contentType: () => 'text/plain',
-    install: async () => ({ name: 'plugin', dirName: 'plugin' }),
-    update: async () => ({ name: 'plugin', dirName: 'plugin' }),
-    uninstall: async () => undefined, startServer: async () => 4000,
-    stopServer: async () => undefined, getServerPort: () => undefined,
-    isServerRunning: () => false, joinPath: (...parts) => parts.join('/'),
-    logError: () => undefined, ...overrides,
-  };
-}
-
-test('setEnabled persists configuration and starts an enabled plugin server', async () => {
-  const operations: string[] = [];
-  const service = createPluginsService(dependencies({
-    scanPlugins: () => [{ name: 'demo', dirName: 'demo', server: { entry: 'server.js' } }],
-    getPluginDirectory: () => '/plugins/demo',
-    saveConfig: () => operations.push('save'),
-    startServer: async () => { operations.push('start'); return 4000; },
-  }));
-  await service.setEnabled('demo', true);
-  assert.deepEqual(operations, ['save', 'start']);
-});
+import assert from 'node:assert/strict';
+import test from 'node:test';
+
+import { createPluginsService } from '../plugins.service.js';
+
+type Dependencies = Parameters<typeof createPluginsService>[0];
+
+function dependencies(overrides: Partial<Dependencies> = {}): Dependencies {
+  return {
+    scanPlugins: () => [], readConfig: () => ({}), saveConfig: () => undefined,
+    getPluginDirectory: () => null, getPluginsDirectory: () => '/plugins',
+    resolveAsset: () => null, assetIsFile: () => false, contentType: () => 'text/plain',
+    install: async () => ({ name: 'plugin', dirName: 'plugin' }),
+    update: async () => ({ name: 'plugin', dirName: 'plugin' }),
+    uninstall: async () => undefined, startServer: async () => 4000,
+    stopServer: async () => undefined, getServerPort: () => undefined,
+    isServerRunning: () => false, joinPath: (...parts) => parts.join('/'),
+    logError: () => undefined, ...overrides,
+  };
+}
+
+test('setEnabled persists configuration and starts an enabled plugin server', async () => {
+  const operations: string[] = [];
+  const service = createPluginsService(dependencies({
+    scanPlugins: () => [{ name: 'demo', dirName: 'demo', server: { entry: 'server.js' } }],
+    getPluginDirectory: () => '/plugins/demo',
+    saveConfig: () => operations.push('save'),
+    startServer: async () => { operations.push('start'); return 4000; },
+  }));
+  await service.setEnabled('demo', true);
+  assert.deepEqual(operations, ['save', 'start']);
+});

package/server/modules/projects/index.ts

@@ -1,11 +1,11 @@
-export {
-  generateDisplayName,
-  getProjectsWithSessions,
-} from './services/projects-with-sessions-fetch.service.js';
-export { updateProjectDisplayName } from './services/project-management.service.js';
-// createProject: used by the worktrees module to register a worktree directory as a switchable project.
-export { createProject } from './services/project-management.service.js';
-// deleteOrArchiveProject: used by Projects routes and Worktrees cleanup to hide or permanently remove a project.
-export { deleteOrArchiveProject, deleteSessionJsonlFilesForProjectPath } from './services/project-delete.service.js';
-// restoreArchivedProject: used by the worktrees module to re-activate an archived project when its worktree is reopened.
-export { restoreArchivedProject } from './services/project-delete.service.js';
+export {
+  generateDisplayName,
+  getProjectsWithSessions,
+} from './services/projects-with-sessions-fetch.service.js';
+export { updateProjectDisplayName } from './services/project-management.service.js';
+// createProject: used by the worktrees module to register a worktree directory as a switchable project.
+export { createProject } from './services/project-management.service.js';
+// deleteOrArchiveProject: used by Projects routes and Worktrees cleanup to hide or permanently remove a project.
+export { deleteOrArchiveProject, deleteSessionJsonlFilesForProjectPath } from './services/project-delete.service.js';
+// restoreArchivedProject: used by the worktrees module to re-activate an archived project when its worktree is reopened.
+export { restoreArchivedProject } from './services/project-delete.service.js';