flashts 1.0.6 → 1.0.8

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 All notable changes to FlashTS will be documented in this file.
 
+## [1.0.8] - 2026-01-25
+
+### Fixed
+
+- **Production Vite Reliability**: Optimized Vite execution and path resolution for production environments.
+- **ENAMETOOLONG Issue**: Relocated the temporary runtime environment from the package directory to the system temp folder (`os.tmpdir()`). This resolves Windows path length limitations.
+- **CLI Exit Responsiveness**: Optimized SIGINT/SIGTERM handling to ensure the CLI and all subprocesses close instantly.
+
+## [1.0.7] - 2026-01-25
+
+### Fixed
+
+- **Vite Preview Timeout**: Resolved the issue where the live preview would hang on "launching" in production by moving `vite` and `@vitejs/plugin-react` to core dependencies and using direct execution.
+- **CLI Exit Responsiveness**: Optimized SIGINT/SIGTERM handling to ensure the CLI and all subprocesses close instantly with a single Ctrl+C, eliminating the previous 500ms delay.
+
 ## [1.0.6] - 2026-01-24
 
 ### Added

package/bin/cli.ts

@@ -10,7 +10,7 @@ const program = new Command();
 program
   .name("flashts")
   .description("FlashTS: High-performance TypeScript Playground CLI")
-  .version("1.0.6")
+  .version("1.0.8")
   .option("-p, --port <number>", "Port to run the server on", "3000")
   .option("-s, --share", "Generate a shareable public link")
   .option("--no-open", "Do not open the browser automatically")
@@ -45,7 +45,7 @@ program
 
     const packageRoot = join(import.meta.dir, "..");
     
-    console.log(`\n⚡ ${pc.bold(pc.cyan("FlashTS"))} ${pc.dim("v1.0.6")}`);
+    console.log(`\n⚡ ${pc.bold(pc.cyan("FlashTS"))} ${pc.dim("v1.0.8")}`);
     console.log(`${pc.green("➜")}  Local:   ${pc.cyan(`http://localhost:${port}`)}`);
 
     // Start the server process
@@ -80,13 +80,16 @@ program
       }, 1000);
     }
 
-    // Keep process alive and ensure total cleanup
-    process.on("SIGINT", () => {
-      console.log(pc.yellow("\nStopping FlashTS..."));
-      // The server itself will handle killing vites on SIGINT
-      serverProc.kill("SIGINT");
-      setTimeout(() => process.exit(0), 500);
-    });
+    const handleExit = () => {
+      // Don't log anything else after this to keep terminal clean
+      try {
+        serverProc.kill(); 
+      } catch (e) {}
+      process.exit(0);
+    };
+
+    process.on("SIGINT", handleExit);
+    process.on("SIGTERM", handleExit);
   });
 
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flashts",
-  "version": "1.0.6",
+  "version": "1.0.8",
   "description": "High-performance TypeScript/JavaScript Playground powered by Bun",
   "main": "server/index.ts",
   "bin": {
@@ -43,14 +43,15 @@
     "react": "^19.2.3",
     "react-dom": "^19.2.0",
     "react-resizable-panels": "^4.4.1",
-    "tailwind-merge": "^3.4.0"
+    "tailwind-merge": "^3.4.0",
+    "vite": "npm:rolldown-vite@7.2.5",
+    "@vitejs/plugin-react": "^5.1.1"
   },
   "devDependencies": {
     "@eslint/js": "^9.39.1",
     "@types/localtunnel": "^2.0.4",
     "@types/react": "^19.2.9",
     "@types/react-dom": "^19.2.3",
-    "@vitejs/plugin-react": "^5.1.1",
     "autoprefixer": "^10.4.23",
     "eslint": "^9.39.1",
     "eslint-plugin-react-hooks": "^7.0.1",

package/server/index.ts

@@ -4,6 +4,7 @@ import { join } from "path";
 import { mkdir, readdir, readFile, rm } from "fs/promises";
 import { serveStatic } from "hono/bun";
 import { streamText } from "hono/streaming";
+import { tmpdir } from "os";
 
 const app = new Hono();
 
@@ -12,8 +13,8 @@ const PACKAGE_ROOT = join(import.meta.dir, "..");
 // Enable CORS for the frontend
 app.use("/*", cors());
 
-// Ensure tmp directory exists in the package root or system temp
-const TMP_DIR = join(PACKAGE_ROOT, "tmp");
+// Ensure tmp directory exists in the system temp
+const TMP_DIR = join(tmpdir(), "flashts-runtime");
 await mkdir(TMP_DIR, { recursive: true });
 
 // Global state management
@@ -38,19 +39,16 @@ try {
         private: true,
         dependencies: {}
     }, null, 2));
-    console.log("-> Initialized new isolated sandbox environment");
 }
 
 // Resilient cleanup for a specific session directory
 const cleanupDir = async (dir: string) => {
     try {
         await rm(dir, { recursive: true, force: true });
-    } catch (e) {
-        // EBUSY is common on Windows if files are locked, ignore it
-    }
+    } catch (e) {}
 };
 
-// Aggressive GC: attempt to delete all session directories that aren't node_modules
+// Aggressive GC
 const performGC = async () => {
     try {
         const entries = await readdir(ISOLATED_ROOT, { withFileTypes: true });
@@ -62,38 +60,35 @@ const performGC = async () => {
     } catch (e) {}
 };
 
-// GUARANTEED Cleanup on CLI exit
+const killActiveProcesses = () => {
+    for (const [id, proc] of vites) {
+        try { proc.kill(); } catch (e) {}
+    }
+    vites.clear();
+    if (currentExecuteProc) {
+        try { currentExecuteProc.kill(); } catch (e) {}
+        currentExecuteProc = null;
+    }
+};
+
 const wipeTempSessions = async () => {
     try {
-        // Kill all vite processes
-        for (const [id, proc] of vites) {
-            try { proc.kill(); } catch (e) {}
-        }
-        vites.clear();
-        
-        // Kill active execution
-        if (currentExecuteProc) {
-            try { currentExecuteProc.kill(); } catch (e) {}
-            currentExecuteProc = null;
-        }
-
+        killActiveProcesses();
         await performGC();
     } catch (e) {}
 };
 
-// Start with a clean slate
 await wipeTempSessions();
 
-process.on("SIGINT", async () => {
-    await wipeTempSessions();
+process.on("SIGINT", () => {
+    killActiveProcesses();
     process.exit(0);
 });
-process.on("SIGTERM", async () => {
-    await wipeTempSessions();
+process.on("SIGTERM", () => {
+    killActiveProcesses();
     process.exit(0);
 });
 
-// Serve static files from the client/dist directory relative to package root
 app.use("/*", serveStatic({ root: join(PACKAGE_ROOT, "client/dist") }));
 
 app.get("/api/health", (c) => c.text("FlashTS API Active"));
@@ -101,29 +96,22 @@ app.get("/api/health", (c) => c.text("FlashTS API Active"));
 app.post("/execute", async (c) => {
   const body = await c.req.json();
   const { files, entryPoint } = body;
+  if (!files || !entryPoint) return c.json({ error: "Invalid project state" }, 400);
 
-  if (!files || !entryPoint) {
-    return c.json({ error: "Invalid project state" }, 400);
-  }
-
-  // Kill any existing execution process
   if (currentExecuteProc) {
     try { currentExecuteProc.kill(); } catch (e) {}
     currentExecuteProc = null;
   }
 
-  // Use a single static folder for all executions - efficient reuse
   const sessionDir = join(ISOLATED_ROOT, "execute-session");
   await mkdir(sessionDir, { recursive: true });
 
   for (const [name, content] of Object.entries(files)) {
-      if (name.endsWith('/')) continue; // Skip directory markers
-      
+      if (name.endsWith('/')) continue;
       const filePath = join(sessionDir, name as string);
       const parts = (name as string).split('/');
       if (parts.length > 1) {
-          const dir = join(sessionDir, join(...parts.slice(0, -1)));
-          await mkdir(dir, { recursive: true });
+          await mkdir(join(sessionDir, join(...parts.slice(0, -1))), { recursive: true });
       }
       await Bun.write(filePath, content as string);
   }
@@ -136,13 +124,9 @@ app.post("/execute", async (c) => {
   currentExecuteProc = proc;
 
   return streamText(c, async (stream) => {
-    stream.onAbort(() => {
-        proc.kill();
-    });
-
+    stream.onAbort(() => { proc.kill(); });
     const stdoutReader = proc.stdout.getReader();
     const stderrReader = proc.stderr.getReader();
-
     const decoder = new TextDecoder();
 
     const read = async (reader: any, type: 'stdout' | 'stderr') => {
@@ -159,26 +143,16 @@ app.post("/execute", async (c) => {
       }
     };
 
-    // Run both readers concurrently
-    await Promise.all([
-      read(stdoutReader, 'stdout'),
-      read(stderrReader, 'stderr')
-    ]);
-
+    await Promise.all([read(stdoutReader, 'stdout'), read(stderrReader, 'stderr')]);
     const exitCode = await proc.exited;
     if (currentExecuteProc === proc) currentExecuteProc = null;
-    
-    try {
-        await stream.writeln(JSON.stringify({ type: 'exit', data: exitCode }));
-    } catch (e) {}
+    try { await stream.writeln(JSON.stringify({ type: 'exit', data: exitCode })); } catch (e) {}
   });
 });
 
 app.post("/install", async (c) => {
     const { package: pkgName } = await c.req.json();
-    if (!pkgName || typeof pkgName !== 'string') {
-        return c.json({ error: "Invalid package name" }, 400);
-    }
+    if (!pkgName || typeof pkgName !== 'string') return c.json({ error: "Invalid package name" }, 400);
 
     try {
         const proc = Bun.spawn([process.execPath, "add", pkgName], {
@@ -186,17 +160,12 @@ app.post("/install", async (c) => {
             stdout: "pipe",
             stderr: "pipe",
         });
-
         const rawOutput = await new Response(proc.stdout).text();
         const rawError = await new Response(proc.stderr).text();
         const output = rawOutput.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
         const error = rawError.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
         const exitCode = await proc.exited;
-
-        if (exitCode !== 0) {
-             return c.json({ success: false, output: error || output }, 500);
-        }
-        
+        if (exitCode !== 0) return c.json({ success: false, output: error || output }, 500);
         return c.json({ success: true, output });
     } catch (err: any) {
         return c.json({ success: false, output: err.message }, 500);
@@ -206,38 +175,25 @@ app.post("/install", async (c) => {
 app.get("/dependencies", async (c) => {
     try {
         const pkgData = JSON.parse(await readFile(ISOLATED_PKG_PATH, "utf-8"));
-        return c.json({
-            ...pkgData.dependencies,
-            ...pkgData.devDependencies
-        });
-    } catch (e) {
-        return c.json({});
-    }
+        return c.json({ ...pkgData.dependencies, ...pkgData.devDependencies });
+    } catch (e) { return c.json({}); }
 });
 
 app.post("/uninstall", async (c) => {
     const { package: pkgName } = await c.req.json();
-    if (!pkgName || typeof pkgName !== 'string') {
-        return c.json({ error: "Invalid package name" }, 400);
-    }
-
+    if (!pkgName || typeof pkgName !== 'string') return c.json({ error: "Invalid package name" }, 400);
     try {
         const proc = Bun.spawn([process.execPath, "remove", pkgName], {
             cwd: ISOLATED_ROOT,
             stdout: "pipe",
             stderr: "pipe",
         });
-
         const rawOutput = await new Response(proc.stdout).text();
         const rawError = await new Response(proc.stderr).text();
         const output = rawOutput.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
         const error = rawError.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
         const exitCode = await proc.exited;
-
-        if (exitCode !== 0) {
-             return c.json({ success: false, output: error || output }, 500);
-        }
-        
+        if (exitCode !== 0) return c.json({ success: false, output: error || output }, 500);
         return c.json({ success: true, output });
     } catch (err: any) {
         return c.json({ success: false, output: err.message }, 500);
@@ -246,89 +202,61 @@ app.post("/uninstall", async (c) => {
 
 async function getPackageTypeTree(pkgName: string) {
     let files: Record<string, string> = {};
-
     async function scan(dir: string, relativePath: string = "") {
         try {
             const entries = await readdir(dir, { withFileTypes: true });
             for (const entry of entries) {
                 const res = join(dir, entry.name);
                 const rel = relativePath ? `${relativePath}/${entry.name}` : entry.name;
-                
                 if (entry.isDirectory()) {
                     if (entry.name === 'node_modules') continue;
                     await scan(res, rel);
                 } else if (entry.name.endsWith(".d.ts") || entry.name === "package.json") {
-                    try {
-                        files[rel] = await readFile(res, "utf-8");
-                    } catch (e) {}
+                    try { files[rel] = await readFile(res, "utf-8"); } catch (e) {}
                 }
             }
         } catch (e) {}
     }
-
-    // 1. Try to find the package in ISOLATED_ROOT
     const isoPkgDir = join(ISOLATED_ROOT, "node_modules", pkgName);
     await scan(isoPkgDir);
-
-    // 2. Try to find @types in ISOLATED_ROOT
-    const typesPkgName = pkgName.startsWith('@') 
-        ? pkgName.slice(1).replace('/', '__') 
-        : pkgName;
+    const typesPkgName = pkgName.startsWith('@') ? pkgName.slice(1).replace('/', '__') : pkgName;
     const isoAtTypesDir = join(ISOLATED_ROOT, "node_modules", "@types", typesPkgName);
     await scan(isoAtTypesDir);
-
-    // 3. Fallback to PACKAGE_ROOT (core types)
     if (Object.keys(files).length === 0) {
         const corePkgDir = join(PACKAGE_ROOT, "node_modules", pkgName);
         await scan(corePkgDir);
         const coreAtTypesDir = join(PACKAGE_ROOT, "node_modules", "@types", typesPkgName);
         await scan(coreAtTypesDir);
     }
-
     return Object.keys(files).length > 0 ? files : null;
 }
 
 app.get("/package-types/:pkg{.+$}", async (c) => {
     const pkgName = c.req.param("pkg");
     const tree = await getPackageTypeTree(pkgName);
-    
-    if (!tree) {
-        return c.json({ error: "Types not found" }, 404);
-    }
-
+    if (!tree) return c.json({ error: "Types not found" }, 404);
     return c.json({ tree, pkgName });
 });
 
 app.post("/preview/start", async (c) => {
   const body = await c.req.json();
   const { files, sessionId: incomingId } = body;
+  if (!files) return c.json({ error: "Invalid project state" }, 400);
 
-  if (!files) {
-    return c.json({ error: "Invalid project state" }, 400);
-  }
-
-  // Kill ALL existing vite processes to be safe
-  for (const [id, proc] of vites) {
-    try { proc.kill(); } catch (e) {}
-  }
+  for (const [id, proc] of vites) { try { proc.kill(); } catch (e) {} }
   vites.clear();
 
-  // GC old session folders (non-blocking)
   while (previewSessionQueue.length >= 5) {
     const oldId = previewSessionQueue.shift();
-    if (oldId) {
-        await cleanupDir(join(ISOLATED_ROOT, "preview-" + oldId));
-    }
+    if (oldId) await cleanupDir(join(ISOLATED_ROOT, "preview-" + oldId));
   }
 
   const sessionId = incomingId || crypto.randomUUID();
   previewSessionQueue.push(sessionId);
-
   const sessionDir = join(ISOLATED_ROOT, "preview-" + sessionId);
-  await cleanupDir(sessionDir); // Ensure clean slate
+  await cleanupDir(sessionDir);
   await mkdir(sessionDir, { recursive: true });
 
-  // Write files
   for (const [name, content] of Object.entries(files)) {
       if (name.endsWith('/')) continue;
       const filePath = join(sessionDir, name as string);
@@ -339,7 +267,6 @@ app.post("/preview/start", async (c) => {
       await Bun.write(filePath, content as string);
   }
 
-  // Ensure index.html exists, if not create a default one for JSX/TSX entry
   const hasIndex = Object.keys(files).some(f => f.toLowerCase() === 'index.html');
   if (!hasIndex) {
       const entryPoint = Object.keys(files).find(f => f.endsWith('.tsx') || f.endsWith('.jsx') || f.endsWith('.ts') || f.endsWith('.js')) || 'src/main.ts';
@@ -359,13 +286,12 @@ app.post("/preview/start", async (c) => {
       `.trim());
   }
   
-  // Find an available port for Vite and HMR
   const tempServer = Bun.serve({ port: 0, fetch: () => new Response() });
   const vitePort = tempServer.port;
   tempServer.stop();
 
-  // Create vite config to handle dependencies from root node_modules
   const normalizedPackageRoot = join(PACKAGE_ROOT).replace(/\\/g, '/');
+  const nodeModulesPath = join(PACKAGE_ROOT, "node_modules").replace(/\\/g, '/');
   
   const viteConfigActual = `
 import { defineConfig } from 'vite';
@@ -402,173 +328,106 @@ export default defineConfig({
       }
     }
   ],
+  resolve: {
+    alias: {
+        'react': '${nodeModulesPath}/react',
+        'react-dom': '${nodeModulesPath}/react-dom',
+        '@vitejs/plugin-react': '${nodeModulesPath}/@vitejs/plugin-react'
+    }
+  },
   root: '.',
   base: './',
   server: {
     port: ${vitePort},
     strictPort: true,
-    host: true,
-    hmr: {
-        host: 'localhost',
-        port: ${vitePort},
-    },
-    fs: {
-      allow: ['${normalizedPackageRoot}']
-    }
+    host: 'localhost',
+    hmr: { host: 'localhost', port: ${vitePort} },
+    fs: { allow: ['${normalizedPackageRoot}', '${TMP_DIR.replace(/\\/g, '/')}'] }
   }
 });
 `;
   await Bun.write(join(sessionDir, "vite.config.ts"), viteConfigActual);
 
-  // Install @vitejs/plugin-react in the temp dir might be needed or we use global
-  // For simplicity, we assume vite-related plugins are available in PACKAGE_ROOT/node_modules
-  
-  const proc = Bun.spawn([process.execPath, "x", "vite", "--port", String(vitePort), "--strictPort", "--host"], {
+  const viteBin = join(PACKAGE_ROOT, "node_modules", "vite", "bin", "vite.js");
+  const proc = Bun.spawn([process.execPath, viteBin, "--port", String(vitePort), "--strictPort", "--host", "localhost"], {
       cwd: sessionDir,
       stdout: "pipe",
       stderr: "pipe",
       env: {
           ...process.env,
-          NODE_PATH: join(PACKAGE_ROOT, "node_modules")
+          NODE_PATH: nodeModulesPath
       }
   });
 
   vites.set(sessionId, proc);
 
-  // Wait for port
   return new Promise<any>((resolve) => {
     let output = "";
-    const timeout = 25000; // Increase to 25s
     const timer = setTimeout(() => {
-        console.error("Vite preview timeout. Current output:", output);
-        resolve(c.json({ error: "Vite timed out starting. Please try again." }, 500));
-    }, timeout);
-
-    const read = async () => {
-        const reader = proc.stdout.getReader();
-        const decoder = new TextDecoder();
-        
+        console.error("Vite preview timeout. Current output/errors:\n", output);
+        resolve(c.json({ error: "Vite timed out. Check terminal for errors." }, 500));
+    }, 25000);
+
+    const read = async (reader: any) => {
+        const dr = new TextDecoder();
         while (true) {
             const { done, value } = await reader.read();
             if (done) break;
-            const chunk = decoder.decode(value, { stream: true });
-            const strippedChunk = chunk.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
-            
-            // Push to session-specific log listeners
-            const listeners = previewLogs.get(sessionId);
-            if (listeners) {
-                listeners.forEach(l => l(strippedChunk));
-            }
-
-            output += strippedChunk;
-            
-            // Match various ways Vite might report the port
-            const match = output.match(/Local:\s+http:\/\/localhost:(\d+)/i) || 
-                          output.match(/Local:\s+http:\/\/127\.0\.0\.1:(\d+)/i) ||
-                          output.match(/Local:\s+http:\/\/.*:(\d+)/i) ||
-                          output.match(/network:\s+http:\/\/.*:(\d+)/i);
-            
+            const chunk = dr.decode(value, { stream: true });
+            const stripped = chunk.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
+            output += stripped;
+            const match = output.match(/Local:.*:(\d+)/i);
             if (match) {
                 clearTimeout(timer);
-                const port = match[1];
-                const hostname = c.req.header('host')?.split(':')[0] || 'localhost';
-                resolve(c.json({ sessionId, port, url: `http://${hostname}:${port}` }));
-                break;
+                resolve(c.json({ sessionId, port: match[1], url: `http://localhost:${match[1]}` }));
             }
-        }
-    };
-
-    const readErr = async () => {
-        const reader = proc.stderr.getReader();
-        const decoder = new TextDecoder();
-        while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-            const errorText = decoder.decode(value, { stream: true });
-            const strippedError = errorText.replace(/\u001b\[[0-9;]*[a-zA-Z]/g, '');
-            
-            // Push to session-specific log listeners
             const listeners = previewLogs.get(sessionId);
-            if (listeners) {
-                listeners.forEach(l => l(strippedError));
-            }
-
-            // Stop logging to GLOBAL server console entirely as requested
+            if (listeners) listeners.forEach(l => l(stripped));
         }
     };
-
-    read();
-    readErr();
+    read(proc.stdout.getReader());
+    read(proc.stderr.getReader());
   });
 });
 
 app.get("/preview/logs/:sessionId", async (c) => {
   const sessionId = c.req.param("sessionId");
-  
   return streamText(c, async (stream) => {
-    const listener = (log: string) => {
-        stream.writeln(log);
-    };
-
-    if (!previewLogs.has(sessionId)) {
-        previewLogs.set(sessionId, []);
-    }
+    const listener = (log: string) => { stream.writeln(log); };
+    if (!previewLogs.has(sessionId)) previewLogs.set(sessionId, []);
     previewLogs.get(sessionId)!.push(listener);
-
     stream.onAbort(() => {
         const listeners = previewLogs.get(sessionId);
-        if (listeners) {
-            previewLogs.set(sessionId, listeners.filter(l => l !== listener));
-        }
+        if (listeners) previewLogs.set(sessionId, listeners.filter(l => l !== listener));
     });
-
-    // Keep connection alive
-    while (true) {
-        await new Promise(r => setTimeout(r, 1000));
-        if (stream.closed) break;
-    }
+    while (!stream.closed) { await new Promise(r => setTimeout(r, 1000)); }
   });
 });
 
 app.post("/preview/sync", async (c) => {
   const { files, sessionId } = await c.req.json();
   if (!files || !sessionId) return c.json({ error: "Missing data" }, 400);
-
   const sessionDir = join(ISOLATED_ROOT, "preview-" + sessionId);
-  
   try {
     for (const [name, content] of Object.entries(files)) {
       if (name.endsWith('/')) continue;
       const filePath = join(sessionDir, name as string);
       const parts = (name as string).split('/');
-      if (parts.length > 1) {
-          await mkdir(join(sessionDir, join(...parts.slice(0, -1))), { recursive: true });
-      }
+      if (parts.length > 1) await mkdir(join(sessionDir, join(...parts.slice(0, -1))), { recursive: true });
       await Bun.write(filePath, content as string);
     }
     return c.json({ success: true });
-  } catch (e: any) {
-    return c.json({ error: e.message }, 500);
-  }
+  } catch (e: any) { return c.json({ error: e.message }, 500); }
 });
 
 app.get("/search", async (c) => {
-    const query = c.req.query("q");
-    if (!query) return c.json({ objects: [] });
-
+    const q = c.req.query("q");
+    if (!q) return c.json({ objects: [] });
     try {
-        const res = await fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(query)}&size=20`);
-        const data = await res.json();
-        return c.json(data);
-    } catch (err) {
-        return c.json({ objects: [] });
-    }
+        const res = await fetch(`https://registry.npmjs.org/-/v1/search?text=${encodeURIComponent(q)}&size=20`);
+        return c.json(await res.json());
+    } catch (err) { return c.json({ objects: [] }); }
 });
 
 const port = parseInt(process.env.PORT || "3000");
-
-Bun.serve({
-    port,
-    fetch: app.fetch,
-    idleTimeout: 60,
-});
+Bun.serve({ port, fetch: app.fetch, idleTimeout: 60 });