neoctl-web 0.1.17 → 0.1.18

package/plugins.mjs

@@ -4,108 +4,201 @@ function normalizePlugin(plugin) {
   if (!/^[a-z0-9][a-z0-9._-]*$/.test(id)) throw new Error(`invalid web plugin id: ${id || '(empty)'}`);
   if (!String(plugin.name || '').trim()) throw new Error(`web plugin ${id} is missing name`);
   if (!String(plugin.version || '').trim()) throw new Error(`web plugin ${id} is missing version`);
-  if (plugin.route !== undefined && typeof plugin.route !== 'function') throw new Error(`web plugin ${id} route must be a function`);
-  if (plugin.presentToolResult !== undefined && typeof plugin.presentToolResult !== 'function') throw new Error(`web plugin ${id} presentToolResult must be a function`);
-  return {
-    ...plugin,
-    id,
-    name: String(plugin.name).trim(),
-    version: String(plugin.version).trim(),
+  for (const key of ['route', 'presentToolResult', 'dispose']) {
+    if (plugin[key] !== undefined && typeof plugin[key] !== 'function') throw new Error(`web plugin ${id} ${key} must be a function`);
+  }
+  return { ...plugin, id, name: String(plugin.name).trim(), version: String(plugin.version).trim(),
     defaultEnabled: plugin.defaultEnabled !== false,
     tools: Array.isArray(plugin.tools) ? plugin.tools : [],
-    promptSections: Array.isArray(plugin.promptSections) ? plugin.promptSections : [],
-  };
+    promptSections: Array.isArray(plugin.promptSections) ? plugin.promptSections : [] };
 }
 
+/** Owns instances, not plugin-specific routes or storage. Published catalogs change synchronously. */
 export function createWebPluginHost(options = {}) {
-  const catalog = (options.plugins || []).map(normalizePlugin).sort((left, right) => left.id.localeCompare(right.id));
-  const ids = catalog.map((plugin) => plugin.id);
-  if (new Set(ids).size !== ids.length) throw new Error('duplicate web plugin id');
-  const enabledIds = resolveEnabledPluginIds(catalog, options.enabled);
-  const enabled = catalog.filter((plugin) => enabledIds.has(plugin.id));
-  const tools = enabled.flatMap((plugin) => plugin.tools);
-  const toolNames = tools.map((tool) => String(tool?.name || '').trim()).filter(Boolean);
-  if (new Set(toolNames).size !== toolNames.length) throw new Error('duplicate tool name across enabled web plugins');
+  let catalog = [];
+  let revision = 0;
+  const entries = new Map();
+  const reserved = new Map();
+  const retired = new Set();
+  let enabledSetting = options.enabled;
+  let mutation = Promise.resolve();
+  const report = error => (options.onError || console.error)(error);
 
-  return {
-    ids: enabled.map((plugin) => plugin.id),
-    tools,
-    promptSections: enabled.flatMap((plugin) => plugin.promptSections),
+  function enabledIds() {
+    // Shared settings make global switches immediately visible to isolated user hosts too.
+    const configured = options.locked ? enabledSetting : options.settings?.globalEnabledIds() ?? enabledSetting;
+    const value = Array.isArray(configured) ? configured.filter(id => catalog.some(p => p.id === id)) : configured;
+    return resolveEnabledPluginIds(catalog, value);
+  }
+  function active() { const ids = enabledIds(); return catalog.filter(p => ids.has(p.id)); }
+  function validate(plugins) {
+    const next = plugins.map(normalizePlugin).sort((a, b) => a.id.localeCompare(b.id));
+    if (new Set(next.map(p => p.id)).size !== next.length) throw new Error('duplicate web plugin id');
+    const names = new Set();
+    for (const plugin of next) for (const tool of plugin.tools) {
+      for (const name of [tool.name, ...(tool.aliases || [])]) {
+        if (names.has(name)) throw new Error(`duplicate tool name or alias across web plugins: ${name}`);
+        if (reserved.has(name)) throw new Error(`plugin tool conflicts with host tool: ${name}`);
+        names.add(name);
+      }
+    }
+    return next;
+  }
+  function drain(entry) {
+    if (!entry.retired || entry.leases || entry.disposal) return;
+    entry.disposal = Promise.resolve().then(() => entry.plugin.dispose?.()).catch(report).finally(() => {
+      retired.delete(entry);
+      entry.finish();
+    });
+  }
+  function lease(plugins) {
+    const owned = plugins.map(p => entries.get(p.id));
+    for (const entry of owned) entry.leases++;
+    let released = false;
+    return () => {
+      if (released) return;
+      released = true;
+      for (const entry of owned) { entry.leases--; drain(entry); }
+    };
+  }
+  function publish(next) {
+    const waits = [];
+    for (const [id, entry] of entries) {
+      if (next.some(p => p.plugin.id === id && p.source === entry.source)) continue;
+      entries.delete(id);
+      entry.retired = true;
+      retired.add(entry);
+      waits.push(entry.drained);
+      drain(entry);
+    }
+    catalog = next.map(({ source, plugin }) => {
+      if (!entries.has(plugin.id)) {
+        let finish;
+        const drained = new Promise(resolve => { finish = resolve; });
+        entries.set(plugin.id, { source, plugin, leases: 0, retired: false, drained, finish });
+      }
+      return entries.get(plugin.id).plugin;
+    });
+    revision++;
+    return Promise.all(waits);
+  }
+  const initial = options.plugins || [];
+  // Explicit startup configuration is strict; persisted removed ids are filtered when resolving.
+  if (typeof enabledSetting === 'string') resolveEnabledPluginIds(initial, enabledSetting);
+  const normalized = validate(initial);
+  publish(normalized.map(plugin => ({ plugin, source: initial.find(p => p.id === plugin.id) })));
+
+  function definitions() {
+    const enabled = enabledIds();
+    return catalog.map(plugin => ({ id: plugin.id, name: plugin.name, version: plugin.version,
+      globallyEnabled: enabled.has(plugin.id), tools: plugin.tools, promptSections: plugin.promptSections,
+      presentToolResult: plugin.presentToolResult }));
+  }
+  const host = {
+    get ids() { return active().map(p => p.id); },
+    get tools() { return active().flatMap(p => p.tools); },
+    get promptSections() { return active().flatMap(p => p.promptSections); },
+    /** Validate before any persistent commit; publication itself cannot fail. */
+    prepare(plugins) {
+      const normalized = validate(plugins);
+      const next = normalized.map(plugin => ({ plugin, source: plugins.find(p => p.id === plugin.id) }));
+      return () => publish(next);
+    },
+    reserveToolNames(names) {
+      const own = new Set(catalog.flatMap(p => p.tools.flatMap(t => [t.name, ...(t.aliases || [])])));
+      for (const name of names) if (own.has(name)) throw new Error(`plugin tool conflicts with host tool: ${name}`);
+      for (const name of names) reserved.set(name, true);
+    },
     runtimePlugins(sessionId) {
-      const overrides = options.settings?.sessionOverrides(sessionId) || {};
       return {
-        externalPlugins: catalog.map((plugin) => ({
-          id: plugin.id,
-          name: plugin.name,
-          version: plugin.version,
-          globallyEnabled: enabledIds.has(plugin.id),
-          tools: plugin.tools,
-          promptSections: plugin.promptSections,
-          presentToolResult: plugin.presentToolResult,
-        })),
-        sessionPluginOverrides: overrides,
-        persistSessionPluginOverrides: (resolvedSessionId, next) => options.settings?.setSessionOverrides(resolvedSessionId, next),
-        resolveSessionPluginOverrides: (resolvedSessionId) => options.settings?.sessionOverrides(resolvedSessionId) || {},
+        externalPlugins: definitions(),
+        resolveExternalPlugins: definitions,
+        reservePluginToolNames: names => host.reserveToolNames(names),
+        acquirePluginSnapshot(overrides = {}) {
+          const enabled = active().filter(p => overrides[p.id] !== false);
+          return { plugins: definitions(), release: lease(enabled) };
+        },
+        sessionPluginOverrides: options.settings?.sessionOverrides(sessionId) || {},
+        persistSessionPluginOverrides: (id, next) => options.settings?.setSessionOverrides(id, next),
+        resolveSessionPluginOverrides: id => options.settings?.sessionOverrides(id) || {},
       };
     },
     snapshot() {
-      const configuredIds = new Set(options.settings?.globalEnabledIds() ?? [...enabledIds]);
-      return {
-        items: catalog.map((plugin) => ({
-          id: plugin.id,
-          name: plugin.name,
-          version: plugin.version,
-          enabled: enabledIds.has(plugin.id),
-          configuredEnabled: configuredIds.has(plugin.id),
-          tools: plugin.tools.map((tool) => tool.name),
-        })),
-        restartRequired: true,
-        locked: options.locked === true,
-      };
+      const enabled = enabledIds();
+      return { revision, items: catalog.map(p => ({ id: p.id, name: p.name, version: p.version,
+        enabled: enabled.has(p.id), configuredEnabled: enabled.has(p.id), tools: p.tools.map(t => t.name) })),
+        restartRequired: false, locked: options.locked === true, installationSupported: Boolean(options.management) };
     },
     async route(req, res, url, helpers = {}) {
       if (req.method === 'GET' && url.pathname === '/api/plugins') {
-        helpers.sendJson?.(res, this.snapshot());
-        return true;
+        helpers.sendJson?.(res, host.snapshot()); return true;
       }
-      if (req.method === 'POST' && url.pathname === '/api/plugins/global') {
+      if (req.method === 'POST' && ['/api/plugins/global', '/api/plugins/install', '/api/plugins/uninstall'].includes(url.pathname)) {
+        const origin = req.headers?.origin;
+        if (req.headers?.['sec-fetch-site'] === 'cross-site' || (origin && !sameHostOrigin(origin, req.headers?.host))) {
+          helpers.sendJson?.(res, { errorCode: 'PLUGIN_ORIGIN_DENIED', error: 'cross-origin plugin management is not allowed' }, 403); return true;
+        }
         if (options.locked) {
-          helpers.sendJson?.(res, { errorCode: 'PLUGINS_LOCKED', error: 'plugins are locked by NEO_WEB_PLUGINS' }, 409);
-          return true;
+          helpers.sendJson?.(res, { errorCode: 'PLUGINS_LOCKED', error: 'plugins are locked by NEO_WEB_PLUGINS' }, 409); return true;
         }
         const body = await helpers.readJsonBody?.(req);
-        const requested = Array.isArray(body?.enabledIds) ? body.enabledIds.map(String) : [];
-        const unknown = requested.filter((id) => !ids.includes(id));
-        if (unknown.length) {
-          helpers.sendJson?.(res, { errorCode: 'PLUGIN_INVALID', error: `unknown web plugin: ${unknown.join(', ')}` }, 400);
-          return true;
-        }
-        await options.settings?.setGlobalEnabled(requested);
-        helpers.sendJson?.(res, { ok: true, enabledIds: [...new Set(requested)].sort(), restartRequired: true });
+        const operation = mutation.catch(() => {}).then(async () => {
+          if (url.pathname !== '/api/plugins/global') {
+            if (!options.management) throw new Error('plugin installation is not configured');
+            if (url.pathname.endsWith('/install')) await options.management.install(body?.directory);
+            else await options.management.uninstall(body?.id);
+          } else {
+            if (!Array.isArray(body?.enabledIds)) throw new Error('enabledIds must be an array');
+            const requested = [...resolveEnabledPluginIds(catalog, body.enabledIds)];
+            await options.settings?.setGlobalEnabled(requested);
+            enabledSetting = requested;
+            revision++;
+          }
+          return { ok: true, enabledIds: host.ids, ...host.snapshot() };
+        });
+        mutation = operation;
+        try { helpers.sendJson?.(res, await operation); }
+        catch (error) { helpers.sendJson?.(res, { errorCode: 'PLUGIN_UPDATE_FAILED', error: error.message || String(error) }, 400); }
         return true;
       }
-      for (const plugin of enabled) {
-        if (typeof plugin.route === 'function' && await plugin.route(req, res, url, helpers)) return true;
+      // Hold a lease through response finish/close, not merely through the route promise (streams).
+      for (const plugin of active()) {
+        if (entries.get(plugin.id)?.plugin !== plugin || !enabledIds().has(plugin.id) || typeof plugin.route !== 'function') continue;
+        const release = lease([plugin]);
+        let routeDone = false, responseDone = false, handled = false;
+        const finish = () => { responseDone = true; if (routeDone) release(); };
+        res.once?.('finish', finish); res.once?.('close', finish);
+        try { handled = await plugin.route(req, res, url, helpers); }
+        finally {
+          routeDone = true;
+          if (!handled || responseDone || res.writableFinished || res.destroyed || !res.once) {
+            res.off?.('finish', finish); res.off?.('close', finish); release();
+          }
+        }
+        if (handled) return true;
       }
       return false;
     },
   };
+  return host;
+}
+
+function sameHostOrigin(origin, host) {
+  try { const url = new URL(origin); return ['http:', 'https:'].includes(url.protocol) && url.host === host; }
+  catch { return false; }
 }
 
 export function resolveEnabledPluginIds(catalog, configured) {
-  const available = new Set(catalog.map((plugin) => plugin.id));
+  const available = new Set(catalog.map(plugin => plugin.id));
   if (Array.isArray(configured)) {
     const requested = configured.map(String);
-    const unknown = requested.filter((id) => !available.has(id));
+    const unknown = requested.filter(id => !available.has(id));
     if (unknown.length) throw new Error(`unknown web plugin: ${unknown.join(', ')}`);
     return new Set(requested);
   }
   const raw = configured === undefined || configured === null ? '' : String(configured).trim();
-  if (!raw) return new Set(catalog.filter((plugin) => plugin.defaultEnabled !== false).map((plugin) => plugin.id));
+  if (!raw) return new Set(catalog.filter(plugin => plugin.defaultEnabled !== false).map(plugin => plugin.id));
   if (raw.toLowerCase() === 'none') return new Set();
   if (raw.toLowerCase() === 'all') return available;
-  const requested = raw.split(',').map((id) => id.trim()).filter(Boolean);
-  const unknown = requested.filter((id) => !available.has(id));
-  if (unknown.length) throw new Error(`unknown web plugin: ${unknown.join(', ')}`);
-  return new Set(requested);
+  return resolveEnabledPluginIds(catalog, raw.split(',').map(id => id.trim()).filter(Boolean));
 }

package/server.mjs

@@ -1,5 +1,6 @@
 import http from 'node:http';
 import { createChunkUploadHandler } from './chunk-uploads.mjs';
+import { createLocalResourceHeaders } from './local-resources.mjs';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
@@ -7,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 const { containerMode, workspaceFs, deliverUpload, verifyExecutionBackend } = await import('./execution-backend.mjs');
 await verifyExecutionBackend();
 const { coreRuntimeInfo, createWebRuntime, loadNeoPlugins, runWebServer } = await import('./core-runtime.mjs');
-const { createWebPluginHost } = await import('./plugins.mjs');
+const { createPluginManager } = await import('./plugin-manager.mjs');
 const { createWebPluginSettings } = await import('./plugin-settings.mjs');
 const { createWebToolSettings } = await import('./tool-settings.mjs');
 const { createWorkspaceRuntimeManager } = await import('./runtime-workspaces.mjs');
@@ -23,6 +24,10 @@ process.env.NEO_CLIENT_REVISION ||= `${coreRuntimeInfo.version}-${Date.now().toS
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const root = path.resolve(process.env.DIST_DIR || path.join(__dirname, 'dist'));
 const host = process.env.APP_HOST || '0.0.0.0';
+const localResourceHeaders = createLocalResourceHeaders({
+  enabled: process.env.NEO_DESKTOP_LOCAL_RESOURCES === '1' && host === '127.0.0.1'
+    && process.env.NEO_EXECUTION_BACKEND !== 'docker',
+});
 const port = Number(process.env.APP_PORT || process.env.PORT || 5173);
 const runtimeTarget = new URL(process.env.NEO_RUNTIME_TARGET || 'http://127.0.0.1:3101');
 const storage = resolveWebStorage();
@@ -40,13 +45,11 @@ const chunkUploads = createChunkUploadHandler({ uploadsDir, baseDir: __dirname,
 const pluginSettings = await createWebPluginSettings(pluginSettingsFile);
 const toolSettings = await createWebToolSettings(toolSettingsFile);
 const pluginEnv = process.env.NEO_WEB_PLUGINS;
-const pluginResources = await loadNeoPlugins({ directories: pluginDir, appDataDir: pluginDataDir });
-const pluginHost = createWebPluginHost({
-  plugins: pluginResources,
+const pluginManager = await createPluginManager({ directory: path.join(dataRoot, 'installed-plugins'), builtInDirectory: pluginDir, loadPlugins: loadNeoPlugins });
+const pluginHost = await pluginManager.createHost({
   enabled: pluginEnv?.trim() ? pluginEnv : pluginSettings.globalEnabledIds(),
-  locked: Boolean(pluginEnv?.trim()),
-  settings: pluginSettings,
-});
+  locked: Boolean(pluginEnv?.trim()), settings: pluginSettings,
+}, { appDataDir: pluginDataDir });
 const embedRuntime = process.env.NEO_EMBED_RUNTIME !== 'false';
 const cpaQuotaMonitor = createCpaQuotaMonitor({ configFile: cpaConfigFile });
 const memoryMonitor = createMemoryMonitor({
@@ -74,7 +77,7 @@ const workspaceRuntime = createWorkspaceRuntimeManager({
 });
 
 const { createIsolationMode } = await import('./isolation.mjs');
-const isolation = await createIsolationMode({ dataRoot, workspaceRoot, pluginDir, pluginSettings, toolSettings, cpaQuotaMonitor, memoryState: () => memoryMonitor.getPublicState() });
+const isolation = await createIsolationMode({ dataRoot, workspaceRoot, pluginDir, pluginManager, pluginSettings, toolSettings, cpaQuotaMonitor, memoryState: () => memoryMonitor.getPublicState() });
 
 const DEFAULT_APP_PROMPT_LIBRARY = [];
 
@@ -128,7 +131,7 @@ async function routeRequest(req, res) {
   const url = new URL(req.url || '/', 'http://localhost');
   try {
     if (await isolation.route(req, res, url)) return;
-    if (await pluginHost.route(req, res, url, { readJsonBody, sendJson })) return;
+    if (await pluginHost.route(req, res, url, { readJsonBody, sendJson, localResourceHeaders })) return;
     if (req.method === 'GET' && url.pathname === '/api/prompt-library') {
       return sendJson(res, { items: await readPromptLibrary() });
     }