neoctl-web 0.1.12 → 0.1.14

package/server.mjs

@@ -1,4 +1,5 @@
 import http from 'node:http';
+import { createChunkUploadHandler } from './chunk-uploads.mjs';
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import path from 'node:path';
@@ -12,6 +13,8 @@ let desktopControlConfig;
   try { desktopControlConfig = raw ? JSON.parse(raw) : undefined; } catch {}
 }
 
+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 { createWebPluginSettings } = await import('./plugin-settings.mjs');
@@ -37,7 +40,9 @@ const root = path.resolve(process.env.DIST_DIR || path.join(__dirname, 'dist'));
 const host = process.env.APP_HOST || '0.0.0.0';
 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 { dataRoot, workspaceRoot } = resolveWebStorage();
+const storage = resolveWebStorage();
+const dataRoot = storage.dataRoot;
+const workspaceRoot = containerMode ? '/workspace' : storage.workspaceRoot;
 const promptLibraryFile = path.resolve(process.env.NEO_PROMPT_LIBRARY_FILE || path.join(dataRoot, 'prompt-library.json'));
 const uploadsDir = path.resolve(process.env.NEO_UPLOADS_DIR || path.join(dataRoot, 'uploads'));
 const pluginDir = path.resolve(process.env.NEO_WEB_PLUGIN_DIR || path.join(__dirname, 'plugins'));
@@ -46,7 +51,7 @@ const cpaConfigFile = path.resolve(process.env.NEO_CPA_CONFIG_FILE || path.join(
 const memoryMonitorFile = path.resolve(process.env.NEO_MEMORY_MONITOR_FILE || path.join(dataRoot, 'memory-monitor.json'));
 const pluginSettingsFile = path.resolve(process.env.NEO_WEB_PLUGIN_SETTINGS_FILE || path.join(dataRoot, 'plugins.json'));
 const toolSettingsFile = path.resolve(process.env.NEO_WEB_TOOL_SETTINGS_FILE || path.join(dataRoot, 'tools.json'));
-const maxUploadBytes = Number(process.env.NEO_UPLOAD_MAX_BYTES || 25 * 1024 * 1024);
+const chunkUploads = createChunkUploadHandler({ uploadsDir, baseDir: __dirname, finalize: containerMode ? (file, url) => deliverUpload(file, url, runtimeTarget) : undefined });
 const pluginSettings = await createWebPluginSettings(pluginSettingsFile);
 const toolSettings = await createWebToolSettings(toolSettingsFile);
 const pluginEnv = process.env.NEO_WEB_PLUGINS;
@@ -86,6 +91,7 @@ const workspaceRuntime = createWorkspaceRuntimeManager({
     ...runtimeOptions,
     ...pluginHost.runtimePlugins(runtimeOptions.sessionId),
     globalToolOverrides: toolSettings.globalOverrides(),
+    resolveGlobalToolOverrides: () => toolSettings.globalOverrides(),
     sessionToolOverrides: toolSettings.sessionOverrides(runtimeOptions.sessionId),
     persistGlobalToolOverrides: (overrides) => toolSettings.setGlobalOverrides(overrides),
     persistSessionToolOverrides: (sessionId, overrides) => toolSettings.setSessionOverrides(sessionId, overrides),
@@ -93,6 +99,10 @@ const workspaceRuntime = createWorkspaceRuntimeManager({
   }),
 });
 
+const { createIsolationMode } = await import('./isolation.mjs');
+const isolation = await createIsolationMode({ dataRoot, workspaceRoot, pluginDir, pluginSettings, toolSettings, cpaQuotaMonitor, memoryState: () => memoryMonitor.getPublicState() });
+if (isolation.enabled && controlEnabled) throw new Error('Isolation mode cannot use desktop control sync');
+
 const DEFAULT_APP_PROMPT_LIBRARY = [];
 
 const mime = {
@@ -117,9 +127,10 @@ const server = http.createServer((req, res) => {
   void routeRequest(req, res);
 });
 
+server.once('close', () => isolation.close());
 server.keepAliveTimeout = 70_000;
 server.headersTimeout = 75_000;
-if (embedRuntime) await startEmbeddedRuntime();
+if (embedRuntime && !isolation.enabled) await startEmbeddedRuntime();
 await cpaQuotaMonitor.start();
 await memoryMonitor.start();
 await new Promise((resolve, reject) => {
@@ -157,6 +168,7 @@ async function startEmbeddedRuntime() {
 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 (req.method === 'GET' && url.pathname === '/api/prompt-library') {
       return sendJson(res, { items: await readPromptLibrary() });
@@ -212,6 +224,7 @@ async function routeRequest(req, res) {
       await writePromptLibrary(ordered);
       return sendJson(res, { ok: true, items: ordered });
     }
+    if (await chunkUploads(req, res, url)) return;
     if (req.method === 'GET' && url.pathname.startsWith('/api/uploads/')) {
       const storedName = decodeURIComponent(url.pathname.slice('/api/uploads/'.length));
       return serveUploadedFile(res, storedName);
@@ -222,7 +235,7 @@ async function routeRequest(req, res) {
     }
     if (req.method === 'POST' && url.pathname === '/api/uploads') {
       const body = await readJsonBody(req);
-      const file = await storeUploadedFile(body);
+      const file = await deliverUpload(await storeUploadedFile(body), url, runtimeTarget);
       return sendJson(res, { ok: true, file });
     }
     if (shouldProxy(url.pathname)) {
@@ -384,7 +397,6 @@ async function storeUploadedFile(payload) {
   if (!data) throw new Error('missing upload data');
   const buffer = Buffer.from(data, 'base64');
   if (!buffer.length) throw new Error('empty upload data');
-  if (buffer.length > maxUploadBytes) throw new Error(`upload too large: max ${maxUploadBytes} bytes`);
   const stamp = new Date().toISOString().replace(/[:.]/g, '-');
   const random = Math.random().toString(36).slice(2, 8);
   const storedName = `${stamp}-${random}-${name}`;
@@ -418,12 +430,14 @@ async function serveUploadedFile(res, storedName) {
     return;
   }
   try {
-    const body = await fsp.readFile(filePath);
+    const stat = await fsp.stat(filePath);
+    if (!stat.isFile()) throw new Error('not a file');
     res.writeHead(200, {
+      'Content-Length': String(stat.size),
       'Content-Type': mime[path.extname(filePath).toLowerCase()] || 'application/octet-stream',
       'Cache-Control': 'public, max-age=31536000, immutable',
     });
-    res.end(body);
+    fs.createReadStream(filePath).on('error', () => res.destroy()).pipe(res);
   } catch {
     res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
     res.end('not found');
@@ -447,6 +461,12 @@ async function serveLocalImage(res, encodedPath) {
     return;
   }
   try {
+    if (containerMode) {
+      const body = await workspaceFs.readFile(absolutePath);
+      res.writeHead(200, { "Content-Type": contentType, "Content-Length": body.length, "Cache-Control": "no-store" });
+      res.end(body);
+      return;
+    }
     const fileStat = await fsp.stat(absolutePath);
     if (!fileStat.isFile()) throw new Error('not a file');
     res.writeHead(200, {

package/tool-settings.mjs

@@ -9,10 +9,14 @@ export async function createWebToolSettings(storageFile) {
     return structuredClone(state);
   }
 
-  async function update(next) {
-    state = next;
-    writeQueue = writeQueue.catch(() => undefined).then(() => writeState(storageFile, state));
-    await writeQueue;
+  async function update(transform) {
+    const mutation = writeQueue.catch(() => undefined).then(async () => {
+      const next = transform(state);
+      await writeState(storageFile, next);
+      state = next;
+    });
+    writeQueue = mutation;
+    await mutation;
   }
 
   return {
@@ -25,16 +29,19 @@ export async function createWebToolSettings(storageFile) {
       return value && typeof value === 'object' ? { ...value } : {};
     },
     async setGlobalOverrides(overrides) {
-      await update({ ...state, global: normalizeOverrides(overrides) });
+      const global = normalizeOverrides(overrides);
+      await update(current => ({ ...current, global }));
     },
     async setSessionOverrides(sessionId, overrides) {
       const id = String(sessionId || '').trim();
       if (!id) throw new Error('session id is required');
-      const sessions = { ...state.sessions };
       const normalized = normalizeOverrides(overrides);
-      if (Object.keys(normalized).length) sessions[id] = normalized;
-      else delete sessions[id];
-      await update({ ...state, sessions });
+      await update(current => {
+        const sessions = { ...current.sessions };
+        if (Object.keys(normalized).length) sessions[id] = normalized;
+        else delete sessions[id];
+        return { ...current, sessions };
+      });
     },
   };
 }