@mrpatronz/nexusflow 0.2.13 → 0.2.17

package/desktop/build-installer.js

@@ -0,0 +1,228 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import https from 'https';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Resolve parent project directory dynamically supporting both nested and sibling structures
+let parentDir = path.resolve(__dirname, '..');
+if (!fs.existsSync(path.join(parentDir, 'package.json')) || 
+    JSON.parse(fs.readFileSync(path.join(parentDir, 'package.json'), 'utf8')).name !== '@mrpatronz/nexusflow') {
+  parentDir = path.resolve(__dirname, '../NexusFlow');
+}
+
+const distInstallerDir = path.resolve(__dirname, 'dist-installer');
+const nodeStagingDir = path.resolve(distInstallerDir, 'node');
+const serverStagingDir = path.resolve(distInstallerDir, 'server');
+const outputDir = path.resolve(__dirname, 'dist-installer-output');
+
+const nodeExeUrl = 'https://nodejs.org/dist/v20.15.0/win-x64/node.exe';
+const nodeExePath = path.resolve(nodeStagingDir, 'node.exe');
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+function downloadFile(url, destPath) {
+  return new Promise((resolve, reject) => {
+    console.log(`Downloading ${url} to ${destPath}...`);
+    const file = fs.createWriteStream(destPath);
+    https.get(url, (response) => {
+      if (response.statusCode !== 200) {
+        reject(new Error(`Failed to download: Status ${response.statusCode}`));
+        return;
+      }
+      response.pipe(file);
+      file.on('finish', () => {
+        file.close();
+        console.log('Download complete.');
+        resolve();
+      });
+    }).on('error', (err) => {
+      fs.unlink(destPath, () => {});
+      reject(err);
+    });
+  });
+}
+
+function sleepSync(ms) {
+  const start = Date.now();
+  while (Date.now() - start < ms) {}
+}
+
+function retryRmSync(dir, maxRetries = 5, delay = 150) {
+  for (let i = 0; i < maxRetries; i++) {
+    try {
+      if (fs.existsSync(dir)) {
+        fs.rmSync(dir, { recursive: true, force: true });
+      }
+      return;
+    } catch (err) {
+      if (i === maxRetries - 1) throw err;
+      console.log(`Directory ${path.basename(dir)} locked by OS, retrying deletion (${i + 1}/${maxRetries}) in ${delay}ms...`);
+      sleepSync(delay);
+    }
+  }
+}
+
+function pruneNodeModules(dir) {
+  if (!fs.existsSync(dir)) return;
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const nameLower = entry.name.toLowerCase();
+      if (
+        nameLower === 'test' ||
+        nameLower === 'tests' ||
+        nameLower === 'examples' ||
+        nameLower === 'docs' ||
+        nameLower === '.github'
+      ) {
+        fs.rmSync(fullPath, { recursive: true, force: true });
+      } else {
+        pruneNodeModules(fullPath);
+      }
+    } else {
+      const ext = path.extname(entry.name).toLowerCase();
+      if (ext === '.map' || ext === '.ts' || ext === '.md') {
+        fs.unlinkSync(fullPath);
+      }
+    }
+  }
+}
+
+async function build() {
+  try {
+    console.log('--- Starting NexusFlow Installer Build ---');
+
+    // 1. Re-create clean staging directories with OS lock retry handling
+    console.log('Cleaning and creating staging directories...');
+    retryRmSync(distInstallerDir);
+    fs.mkdirSync(distInstallerDir, { recursive: true });
+    fs.mkdirSync(nodeStagingDir, { recursive: true });
+    fs.mkdirSync(serverStagingDir, { recursive: true });
+
+    try {
+      retryRmSync(outputDir);
+      fs.mkdirSync(outputDir, { recursive: true });
+    } catch (err) {
+      console.log('Output directory locked by shell, clearing files inside instead...');
+      if (fs.existsSync(outputDir)) {
+        const files = fs.readdirSync(outputDir);
+        for (const file of files) {
+          fs.rmSync(path.join(outputDir, file), { recursive: true, force: true });
+        }
+      } else {
+        fs.mkdirSync(outputDir, { recursive: true });
+      }
+    }
+
+    // 2. Copy Neutralino assets
+    console.log('Copying Neutralino assets...');
+    const winExeSrc = path.resolve(__dirname, 'dist/nexusflow-desktop/nexusflow-desktop-win_x64.exe');
+    const resourcesNeuSrc = path.resolve(__dirname, 'dist/nexusflow-desktop/resources.neu');
+
+    if (!fs.existsSync(winExeSrc) || !fs.existsSync(resourcesNeuSrc)) {
+      throw new Error('Neutralino build outputs not found. Please run "npm run build" first in the desktop folder.');
+    }
+
+    fs.copyFileSync(winExeSrc, path.resolve(distInstallerDir, 'nexusflow-desktop-win_x64.exe'));
+    fs.copyFileSync(resourcesNeuSrc, path.resolve(distInstallerDir, 'resources.neu'));
+
+    // 3. Copy Hono backend server files
+    console.log('Copying Hono server dist and package.json...');
+    const serverDistSrc = path.resolve(parentDir, 'dist');
+    const serverPackageJsonSrc = path.resolve(parentDir, 'package.json');
+
+    if (!fs.existsSync(serverDistSrc) || !fs.existsSync(serverPackageJsonSrc)) {
+      throw new Error('NexusFlow server build outputs not found. Please run "npm run build" first in NexusFlow.');
+    }
+
+    copyDir(serverDistSrc, path.resolve(serverStagingDir, 'dist'));
+    fs.copyFileSync(serverPackageJsonSrc, path.resolve(serverStagingDir, 'package.json'));
+
+    // Copy templates/resources
+    const serverResourcesSrc = path.resolve(parentDir, 'resources');
+    if (fs.existsSync(serverResourcesSrc)) {
+      copyDir(serverResourcesSrc, path.resolve(serverStagingDir, 'resources'));
+    }
+
+    // 4. Install server dependencies and prune unused assets
+    console.log('Installing production dependencies for staging server...');
+    execSync('npm install --omit=dev', { cwd: serverStagingDir, stdio: 'inherit', shell: true });
+    
+    console.log('Pruning non-runtime files from node_modules (maps, tests, docs)...');
+    pruneNodeModules(path.resolve(serverStagingDir, 'node_modules'));
+
+    // 5. Download embedded Node.js executable
+    await downloadFile(nodeExeUrl, nodeExePath);
+
+    // 6. Locate and run Inno Setup compiler (ISCC.exe)
+    console.log('Locating Inno Setup compiler...');
+    const userIsccPath = path.join(
+      process.env.USERPROFILE || 'C:\\Users\\default',
+      'AppData\\Local\\Programs\\Inno Setup 6\\ISCC.exe'
+    );
+    const globalIsccPath = 'C:\\Program Files (x86)\\Inno Setup 6\\ISCC.exe';
+
+    let isccPath = '';
+    if (fs.existsSync(userIsccPath)) {
+      isccPath = userIsccPath;
+    } else if (fs.existsSync(globalIsccPath)) {
+      isccPath = globalIsccPath;
+    } else {
+      // Try resolving from PATH
+      try {
+        execSync('iscc /?', { stdio: 'ignore', shell: true });
+        isccPath = 'iscc';
+      } catch {
+        throw new Error('Inno Setup compiler (ISCC.exe) not found. Please verify it is installed.');
+      }
+    }
+
+    console.log(`Using Inno Setup compiler: ${isccPath}`);
+    const issScriptPath = path.resolve(__dirname, 'installer/nexusflow.iss');
+    console.log(`Compiling installer script: ${issScriptPath}...`);
+    execSync(`"${isccPath}" "${issScriptPath}"`, { stdio: 'inherit', shell: true });
+
+    // 7. Check if file got redirected to VirtualStore due to Windows virtualization and move it back
+    const expectedOutputExe = path.resolve(outputDir, 'NexusFlowSetup.exe');
+    if (!fs.existsSync(expectedOutputExe)) {
+      console.log('Checking for Windows VirtualStore redirection...');
+      const localAppData = process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || 'C:\\Users\\default', 'AppData\\Local');
+      // VirtualStore mirrors the absolute path starting from the drive root
+      const relativePathFromDrive = __dirname.replace(/^[a-zA-Z]:/, '');
+      const virtualStorePath = path.join(localAppData, 'VirtualStore', relativePathFromDrive, 'dist-installer-output', 'NexusFlowSetup.exe');
+      
+      if (fs.existsSync(virtualStorePath)) {
+        console.log(`Detected VirtualStore redirection! Moving installer from ${virtualStorePath} to ${expectedOutputExe}...`);
+        fs.copyFileSync(virtualStorePath, expectedOutputExe);
+        fs.unlinkSync(virtualStorePath);
+      } else {
+        throw new Error('Installer compiled successfully but the output file could not be found anywhere.');
+      }
+    }
+
+    console.log('--- Installer Build Completed Successfully ---');
+    console.log(`Installer location: ${expectedOutputExe}`);
+  } catch (error) {
+    console.error('Installer build failed:', error.message);
+    process.exit(1);
+  }
+}
+
+build();

package/desktop/build.js

@@ -0,0 +1,118 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Resolve parent project directory dynamically supporting both nested and sibling structures
+let parentDir = path.resolve(__dirname, '..');
+if (!fs.existsSync(path.join(parentDir, 'package.json')) || 
+    JSON.parse(fs.readFileSync(path.join(parentDir, 'package.json'), 'utf8')).name !== '@mrpatronz/nexusflow') {
+  parentDir = path.resolve(__dirname, '../NexusFlow');
+}
+
+const guiAssetsDir = path.resolve(parentDir, 'dist/gui');
+const resourcesDir = path.resolve(__dirname, 'resources');
+
+function copyDir(src, dest) {
+  fs.mkdirSync(dest, { recursive: true });
+  const entries = fs.readdirSync(src, { withFileTypes: true });
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name);
+    const destPath = path.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath);
+    } else {
+      fs.copyFileSync(srcPath, destPath);
+    }
+  }
+}
+
+try {
+  const binDir = path.resolve(__dirname, 'bin');
+  const neutralinoJsPath = path.resolve(resourcesDir, 'neutralino.js');
+
+  // Check if bin directory or resources/neutralino.js is missing
+  if (!fs.existsSync(binDir) || !fs.existsSync(neutralinoJsPath)) {
+    console.log('Detected missing Neutralino binaries or client library. Running npx neu update...');
+    try {
+      execSync('npx --no-install neu update', { cwd: __dirname, stdio: 'inherit', shell: true });
+    } catch (err) {
+      console.log('npx failed, trying direct node execution of local neu CLI binary for update...');
+      const localNeuBin = path.join(__dirname, 'node_modules/@neutralinojs/neu/bin/neu');
+      if (fs.existsSync(localNeuBin)) {
+        execSync(`node "${localNeuBin}" update`, { cwd: __dirname, stdio: 'inherit', shell: true });
+      } else {
+        throw new Error('Local neutralino CLI binary not found. Please run npm install first in the desktop directory.');
+      }
+    }
+  }
+
+  // 1. Compile the parent project
+  if (!process.env.CI) {
+    console.log('Compiling parent project (NexusFlow)...');
+    execSync('npm run build', { cwd: parentDir, stdio: 'inherit', shell: true });
+  } else {
+    console.log('Running in CI environment. Skipping parent project compilation.');
+  }
+
+  // Read existing neutralino.js before purging resources folder
+  let neutralinoJsContent = '';
+  if (fs.existsSync(neutralinoJsPath)) {
+    console.log('Reading existing neutralino.js into memory...');
+    neutralinoJsContent = fs.readFileSync(neutralinoJsPath, 'utf8');
+  }
+
+  // 2. Clear and copy GUI assets to desktop/resources
+  console.log('Copying web assets to desktop/resources...');
+  if (fs.existsSync(resourcesDir)) {
+    fs.rmSync(resourcesDir, { recursive: true, force: true });
+  }
+  fs.mkdirSync(resourcesDir, { recursive: true });
+  copyDir(guiAssetsDir, resourcesDir);
+
+  // Write neutralino.js back to resources directory
+  if (neutralinoJsContent) {
+    console.log('Writing neutralino.js back to resources folder...');
+    fs.writeFileSync(neutralinoJsPath, neutralinoJsContent, 'utf8');
+  }
+
+  // 3. Inject neutralino.js client script tag
+  console.log('Injecting neutralino.js client script tag into index.html...');
+  const indexHtmlPath = path.join(resourcesDir, 'index.html');
+  if (fs.existsSync(indexHtmlPath)) {
+    let htmlContent = fs.readFileSync(indexHtmlPath, 'utf8');
+    if (!htmlContent.includes('neutralino.js')) {
+      // Inject before </head>
+      htmlContent = htmlContent.replace('</head>', '<script src="/neutralino.js"></script>\n</head>');
+      fs.writeFileSync(indexHtmlPath, htmlContent, 'utf8');
+      console.log('Successfully injected neutralino.js.');
+    } else {
+      console.log('neutralino.js already injected.');
+    }
+  } else {
+    console.error('Error: index.html not found in resources directory!');
+    process.exit(1);
+  }
+
+  // 4. Execute neu build using the locally installed CLI binary
+  console.log('Executing neu build using locally installed CLI binary...');
+  try {
+    execSync('npx --no-install neu build', { cwd: __dirname, stdio: 'inherit', shell: true });
+  } catch (err) {
+    console.log('npx failed, trying direct node execution of local neu CLI binary...');
+    const localNeuBin = path.join(__dirname, 'node_modules/@neutralinojs/neu/bin/neu');
+    if (fs.existsSync(localNeuBin)) {
+      execSync(`node "${localNeuBin}" build`, { cwd: __dirname, stdio: 'inherit', shell: true });
+    } else {
+      throw new Error('Local neutralino CLI binary not found. Please run npm install first in the desktop directory.');
+    }
+  }
+
+  console.log('Build completed successfully.');
+} catch (error) {
+  console.error('Build failed:', error.message);
+  process.exit(1);
+}

package/desktop/installer/nexusflow.iss

@@ -0,0 +1,35 @@
+; NexusFlow Desktop Installer Script for Inno Setup
+; Creates a user-level (no-admin-needed) installer.
+
+[Setup]
+AppName=NexusFlow
+AppVersion=0.2.17
+AppPublisher=Antigravity team
+AppPublisherURL=https://github.com/mrpatronz/nexusflow
+DefaultDirName={localappdata}\Programs\NexusFlow
+DefaultGroupName=NexusFlow
+DisableProgramGroupPage=yes
+UninstallDisplayIcon={app}\nexusflow-desktop-win_x64.exe
+Compression=lzma2
+SolidCompression=yes
+OutputDir=..\dist-installer-output
+OutputBaseFilename=NexusFlowSetup
+PrivilegesRequired=lowest
+WizardStyle=modern
+
+[Languages]
+Name: "english"; MessagesFile: "compiler:Default.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[Files]
+Source: "..\dist-installer\*"; DestDir: "{app}"; Flags: recursesubdirs createallsubdirs ignoreversion
+
+[Icons]
+Name: "{group}\NexusFlow"; Filename: "{app}\nexusflow-desktop-win_x64.exe"
+Name: "{userdesktop}\NexusFlow"; Filename: "{app}\nexusflow-desktop-win_x64.exe"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\nexusflow-desktop-win_x64.exe"; Description: "{cm:LaunchProgram,NexusFlow}"; Flags: nowait postinstall skipifsilent
+Filename: "{app}\nexusflow-desktop-win_x64.exe"; Flags: nowait skipifnotsilent

package/desktop/neutralino.config.json

@@ -0,0 +1,39 @@
+{
+  "$schema": "https://raw.githubusercontent.com/neutralinojs/neutralinojs/main/schemas/neutralino.config.schema.json",
+  "applicationId": "js.neutralino.nexusflow",
+  "version": "1.0.0",
+  "applicationIcon": "resources/app_logo.png",
+  "defaultMode": "window",
+  "port": 0,
+  "documentRoot": "/resources/",
+  "url": "/",
+  "enableServer": true,
+  "enableNativeAPI": true,
+  "logging": {
+    "enabled": true,
+    "writeToLogFile": true
+  },
+  "modes": {
+    "window": {
+      "title": "NexusFlow Dashboard",
+      "icon": "/resources/app_logo.png",
+      "width": 1000,
+      "height": 700,
+      "minWidth": 400,
+      "minHeight": 300,
+      "center": true,
+      "fullScreen": false,
+      "alwaysOnTop": false,
+      "enableInspector": true,
+      "openInspectorOnStartup": false,
+      "resizable": true
+    }
+  },
+  "cli": {
+    "binaryName": "nexusflow-desktop",
+    "resourcesPath": "/resources/",
+    "clientLibrary": "/resources/neutralino.js",
+    "binaryVersion": "6.8.0",
+    "clientVersion": "6.8.0"
+  }
+}