yapin.js-client 0.1.0 → 0.1.4

package/src/config/defaults.js

@@ -55,20 +55,44 @@ export const defaults = Object.freeze({
   pages: {
     section: null,
     position: 'end',
-    plugins: { title: 'Plugins', order: 10 },
-    themes: { title: 'Themes', order: 20 },
-    settings: { title: 'Settings', order: 5 },
+    plugins: { title: 'Plugins', order: 10, icon: 'puzzle' },
+    themes: { title: 'Themes', order: 20, icon: 'palette' },
+    settings: { title: 'Settings', order: 5, icon: 'sliders' },
   },
 
   about: {
     title: 'About',
     order: 0,
+    icon: 'info',
+    logo: null,
     intro: null,
     sections: {},
     fields: {},
     actions: {},
   },
 
+  welcome: {
+    enabled: true,
+    icon: 'sparkles',
+    title: 'Welcome to {name}',
+    subtitle: null,
+    steps: [],
+    actionLabel: 'Get started',
+    dismissible: true,
+    dismissLabel: 'Skip',
+  },
+
+  whatsNew: {
+    enabled: true,
+    icon: 'rocket',
+    title: "What's new in {name} {version}",
+    subtitle: null,
+    entries: [],
+    actionLabel: 'Got it',
+    dismissible: true,
+    dismissLabel: null,
+  },
+
   badges: {
     enabled: true,
     sources: [],
@@ -114,6 +138,9 @@ export const defaults = Object.freeze({
       icon: null,
       company: null,
       sign: null,
+      nsis: true,
+      sidebar: null,
+      header: null,
     },
   },
 });

package/src/config/load.js

@@ -8,7 +8,7 @@ import { idPattern } from '../shared/constants.js';
 export const CONFIG_FILES = ['yapin-client.config.js', 'yapin-client.config.mjs', 'yapin-client.config.json'];
 
 /** Sections that reach the running client app, so they must be JSON. */
-const RUNTIME_SECTIONS = ['settings', 'runtime', 'plugins', 'themes', 'pages', 'about', 'badges', 'api', 'host', 'desktop', 'origins', 'links'];
+const RUNTIME_SECTIONS = ['settings', 'runtime', 'plugins', 'themes', 'pages', 'about', 'welcome', 'whatsNew', 'badges', 'api', 'host', 'desktop', 'origins', 'links'];
 
 export class ConfigError extends Error {
   constructor(problems, file) {
@@ -154,6 +154,14 @@ export function validateConfig(input, { root = process.cwd(), file = null } = {}
   }
   if (config.icon) config.icon = resolve(root, config.icon);
   if (config.installer.windows?.icon) config.installer.windows.icon = resolve(root, config.installer.windows.icon);
+  if (typeof config.installer.windows?.nsis === 'string') config.installer.windows.nsis = resolve(root, config.installer.windows.nsis);
+  for (const [key, size] of [['sidebar', '164×314'], ['header', '150×57']]) {
+    const file = config.installer.windows?.[key];
+    if (!file) continue;
+    config.installer.windows[key] = resolve(root, file);
+    if (!/\.bmp$/i.test(file)) problems.push(`installer.windows.${key} must be a .bmp (${size} pixels)`);
+    else if (!existsSync(config.installer.windows[key])) problems.push(`installer.windows.${key} ${config.installer.windows[key]} doesn't exist`);
+  }
   if (config.installer.windows?.sign && (typeof config.installer.windows.sign !== 'string' || !config.installer.windows.sign.includes('{file}'))) problems.push('installer.windows.sign must be a command containing {file}, like: signtool sign /fd sha256 /a {file}');
   if (!['leave', 'relax'].includes(config.desktop.csp)) problems.push('desktop.csp must be "leave" or "relax"');
   if (!['default', 'minimal', 'showcase'].includes(config.installer.preset)) problems.push('installer.preset must be "default", "minimal" or "showcase"');

package/src/desktop/preload.cjs

@@ -64,6 +64,8 @@ const PREFIX = 'yapin-client:';
     },
   });
 
-  const code = `(${boot.runtime})().default(${JSON.stringify(boot.args)});\n//# sourceURL=yapin-client://${encodeURIComponent(boot.args.manifest.id)}/runtime.js`;
+  // `void 0` keeps the script's result undefined: executeJavaScript converts the result back to this world,
+  // and converting the Client object (which reaches window and the whole DOM) hangs the page before it loads.
+  const code = `(${boot.runtime})().default(${JSON.stringify(boot.args)});\nvoid 0;\n//# sourceURL=yapin-client://${encodeURIComponent(boot.args.manifest.id)}/runtime.js`;
   webFrame.executeJavaScript(code).catch((error) => console.error('[yapin-client] the client app failed to start', error));
 })();

package/src/desktop/shim.cjs

@@ -110,7 +110,8 @@ module.exports = function setup({ payloadDir }) {
     os: `${os.type()} ${os.release()} (${process.arch})`,
     platform: process.platform,
   };
-  log('info', `starting ${manifest.name} ${manifest.version}${safeMode ? ' in safe mode' : ''}`);
+  log('info', `starting ${manifest.name} ${manifest.version}${safeMode ? ' in safe mode' : ''} (pid ${process.pid}, args ${JSON.stringify(process.argv.slice(1))})`);
+  app.on('will-quit', () => log('info', `quitting (pid ${process.pid})`));
 
   /** Only the main frame of Yapin’s own pages may talk to us. */
   const trusted = (event) => {
@@ -179,16 +180,30 @@ module.exports = function setup({ payloadDir }) {
     return true;
   };
 
-  handleSync('boot', () => ({
-    runtime,
-    args: {
-      manifest,
-      nativeKey,
-      safeMode,
-      environment,
-      snapshot: { storage: readStorage(), userPlugins: readAllUser('plugins'), userThemes: readAllUser('themes') },
-    },
-  }));
+  ipcMain.on(`${PREFIX}boot`, (event) => {
+    const url = event.senderFrame ? event.senderFrame.url : '(no frame)';
+    if (!trusted(event)) {
+      event.returnValue = null;
+      return;
+    }
+    const started = Date.now();
+    try {
+      event.returnValue = {
+        runtime,
+        args: {
+          manifest,
+          nativeKey,
+          safeMode,
+          environment,
+          snapshot: { storage: readStorage(), userPlugins: readAllUser('plugins'), userThemes: readAllUser('themes') },
+        },
+      };
+      log('info', `boot served to ${url} in ${Date.now() - started} ms`);
+    } catch (error) {
+      log('error', 'boot', error);
+      event.returnValue = null;
+    }
+  });
   handleSync('storage-write-sync', (_event, ns, json) => writeStorage(ns, json));
   handle('storage-write', (_event, ns, json) => writeStorage(ns, json));
   handle('list', (_event, kind) => (KINDS.has(kind) ? listFiles(kind) : []));
@@ -390,6 +405,39 @@ module.exports = function setup({ payloadDir }) {
   /** Crash-loop protection: two renderer crashes soon after loading mean the next start is in safe mode. */
   app.on('web-contents-created', (_event, contents) => {
     let loadedAt = 0;
+    let navigatedAt = 0;
+    const ours = (url) => {
+      try {
+        return origins.has(new URL(url).origin);
+      } catch {
+        return false;
+      }
+    };
+    // Enough to tell from main.log alone why a page never finished loading.
+    contents.on('did-start-navigation', (details) => {
+      if (!details.isMainFrame || details.isSameDocument || !ours(details.url)) return;
+      navigatedAt = Date.now();
+      log('info', `loading ${details.url}`);
+    });
+    contents.on('dom-ready', () => {
+      if (navigatedAt && ours(contents.getURL())) log('info', `dom-ready after ${Date.now() - navigatedAt} ms`);
+    });
+    contents.on('did-fail-load', (_e, code, description, url, isMainFrame) => {
+      if (isMainFrame && code !== -3 && ours(url)) log('warn', `load failed: ${description} (${code}) ${url}`);
+    });
+    contents.on('preload-error', (_e, file, error) => log('error', `preload ${file} failed`, error));
+    let consoleErrors = 0;
+    contents.on('console-message', (event, level, message, line, sourceId) => {
+      const text = event && event.message !== undefined ? event.message : message;
+      const severity = event && event.level !== undefined ? event.level : level;
+      if ((severity !== 'error' && severity !== 3) || consoleErrors >= 30 || !ours(contents.getURL())) return;
+      consoleErrors++;
+      const source = (event && event.sourceId) || sourceId || '';
+      log('warn', `page error: ${text}${source ? ` (${source}:${(event && event.lineNumber) || line || 0})` : ''}`);
+    });
+    contents.on('unresponsive', () => {
+      if (ours(contents.getURL())) log('warn', 'page unresponsive');
+    });
     contents.on('did-finish-load', () => {
       loadedAt = Date.now();
       setTimeout(() => {
@@ -400,6 +448,7 @@ module.exports = function setup({ payloadDir }) {
       }, 60_000);
     });
     contents.on('render-process-gone', (_e, details) => {
+      if (ours(contents.getURL())) log('warn', `page process gone: ${details.reason} (exit code ${details.exitCode})`);
       if (details.reason === 'clean-exit' || details.reason === 'killed') return;
       if (Date.now() - loadedAt < 60_000) {
         state.crashes = (state.crashes || 0) + 1;

package/src/installer/main.js

@@ -3,6 +3,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { parseArgs } from 'node:util';
 import { runCli, style } from './cli.js';
+import { runNsis } from './nsis.js';
 import { createOperations } from './operations.js';
 import { openBrowser, startServer } from './server.js';
 
@@ -52,6 +53,7 @@ async function main() {
       path: { type: 'string', multiple: true },
       index: { type: 'string' },
       help: { type: 'boolean', short: 'h' },
+      nsis: { type: 'string' },
     },
   });
   if (values.help) {
@@ -63,6 +65,9 @@ async function main() {
   const command = positionals[0];
   const options = { yes: values.yes, close: values.close, purge: values.purge, index: values.index, launch: values['no-launch'] ? false : undefined };
 
+  // The Windows setup wizard (NSIS) asks with --nsis <file> and reads the answer from that file.
+  if (values.nsis) return runNsis({ operations, command, options, file: values.nsis });
+
   // The Windows setup .exe passes --gui: it has no terminal, but the page doesn't need one.
   if (values.cli || command || installer.gui === false || (!process.stdout.isTTY && !values.gui)) {
     return runCli({ installer, operations, command, options });

package/src/installer/nsis.js

@@ -0,0 +1,75 @@
+import { writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+
+/**
+ * The installer's side of the Windows setup wizard (an NSIS installer, see src/build/nsis.js). NSIS runs
+ * installer.mjs with `--nsis <file>` and reads the answer back from that file with ReadINIStr:
+ *
+ *   status --nsis status.ini                 what's installed where
+ *   install --nsis result.ini --index 1 ...  also repair and uninstall; prints each step for the log
+ *
+ * The INI is UTF-16 with a byte order mark, the form Windows' INI functions read as Unicode. Lines for
+ * the log are plain ASCII, because nsExec only recognises UTF-16 output.
+ */
+
+/** { section: { key: value } } as an INI file. Values are kept on one line. */
+export function iniFile(sections) {
+  const lines = [];
+  for (const [name, values] of Object.entries(sections)) {
+    lines.push(`[${name}]`);
+    for (const [key, value] of Object.entries(values)) {
+      const text = value === true ? '1' : value === false ? '0' : String(value ?? '');
+      lines.push(`${key}=${text.replace(/[\r\n]+/g, ' ').trim()}`);
+    }
+    lines.push('');
+  }
+  return Buffer.concat([Buffer.from([0xff, 0xfe]), Buffer.from(lines.join('\r\n'), 'utf16le')]);
+}
+
+/** The closest ASCII to `text`, for nsExec's log. */
+export function asciiLine(text) {
+  return String(text)
+    .replace(/[‘’]/g, "'")
+    .replace(/[“”]/g, '"')
+    .replace(/…/g, '...')
+    .replace(/[–—]/g, '-')
+    .normalize('NFKD')
+    .replace(/[̀-ͯ]/g, '')
+    .replace(/[^\x20-\x7e]/g, '?');
+}
+
+export function statusSections(status) {
+  const sections = {
+    status: { count: status.installs.length, running: status.running === null ? '' : status.running, hasData: status.hasData },
+  };
+  status.installs.forEach((inst, i) => {
+    sections[`install${i}`] = {
+      location: inst.location,
+      appVersion: inst.appVersion ?? '',
+      state: inst.state,
+      ours: Boolean(inst.installed?.ours),
+      installedName: inst.installed?.name ?? '',
+      installedVersion: inst.installed?.version ?? '',
+      canInstall: inst.canInstall,
+      blocked: inst.blocked ?? '',
+      executable: inst.executable ?? '',
+      folder: inst.executable ? dirname(inst.executable) : '',
+    };
+  });
+  return sections;
+}
+
+export async function runNsis({ operations, command, options = {}, file, log = (line) => console.log(line) }) {
+  if (command === 'status') {
+    writeFileSync(file, iniFile(statusSections(await operations.status())));
+    return 0;
+  }
+  if (!['install', 'repair', 'uninstall'].includes(command)) {
+    writeFileSync(file, iniFile({ result: { ok: false, error: `Unknown command "${command}"` } }));
+    return 1;
+  }
+  const index = options.index === undefined ? 0 : Number(options.index) - 1;
+  const result = await operations[command]({ index, close: options.close === true, purge: options.purge === true, launch: false, onStep: (step) => log(asciiLine(step)) });
+  writeFileSync(file, iniFile({ result: { ok: result.ok, error: result.error ?? '', hint: result.hint ?? '', previous: result.result?.previous ?? '' } }));
+  return result.ok ? 0 : 1;
+}

package/src/installer/operations.js

@@ -42,16 +42,21 @@ export function createOperations({ config, payload, platform = process.platform,
     return found;
   };
 
-  const ensureClosed = async (allowClose) => {
+  const ensureClosed = async (allowClose, onStep) => {
     if (!processName || !(await isRunning(processName, platform))) return;
     if (!allowClose) throw new InstallError(`${target.productName} is running`, { code: 'RUNNING', hint: `Close ${target.productName} (check the system tray too), or let the installer close it.` });
+    onStep(`Closing ${target.productName}`);
     if (!(await closeApp(processName, { platform }))) throw new InstallError(`Couldn't close ${target.productName}`, { code: 'RUNNING', hint: 'Close it yourself, then try again.' });
   };
 
-  const run = async (fn) => {
+  /** Runs one action, collecting its steps (and passing each to `onStep` as it happens). */
+  const run = async (fn, onStep = () => {}) => {
     const steps = [];
     try {
-      const result = await fn((step) => steps.push(step));
+      const result = await fn((step) => {
+        steps.push(step);
+        onStep(step);
+      });
       return { ok: true, steps, result };
     } catch (error) {
       return { ok: false, steps, error: error.message, code: error.code ?? 'FAILED', hint: error.hint ?? null };
@@ -72,34 +77,34 @@ export function createOperations({ config, payload, platform = process.platform,
       };
     },
 
-    install({ index, close = false, launch = false } = {}) {
-      return run(async (onStep) => {
+    install({ index, close = false, launch = false, onStep } = {}) {
+      return run(async (step) => {
         const found = pick(index);
-        await ensureClosed(close);
-        const result = install({ resources: found.resources, payload, target, onStep });
+        await ensureClosed(close, step);
+        const result = install({ resources: found.resources, payload, target, onStep: step });
         if (launch && found.executable) launchApp(found.executable, { platform });
         return result;
-      });
+      }, onStep);
     },
 
-    repair({ index, close = false, launch = false } = {}) {
-      return run(async (onStep) => {
+    repair({ index, close = false, launch = false, onStep } = {}) {
+      return run(async (step) => {
         const found = pick(index);
-        await ensureClosed(close);
-        const result = repair({ resources: found.resources, payload, target, id: manifest.id, onStep });
+        await ensureClosed(close, step);
+        const result = repair({ resources: found.resources, payload, target, id: manifest.id, onStep: step });
         if (launch && found.executable) launchApp(found.executable, { platform });
         return result;
-      });
+      }, onStep);
     },
 
-    uninstall({ index, purge = false, close = false, launch = false } = {}) {
-      return run(async (onStep) => {
+    uninstall({ index, purge = false, close = false, launch = false, onStep } = {}) {
+      return run(async (step) => {
         const found = pick(index);
-        await ensureClosed(close);
-        const result = uninstall({ resources: found.resources, target, id: manifest.id, purge, onStep });
+        await ensureClosed(close, step);
+        const result = uninstall({ resources: found.resources, target, id: manifest.id, purge, onStep: step });
         if (launch && found.executable) launchApp(found.executable, { platform });
         return result;
-      });
+      }, onStep);
     },
 
     launch({ index } = {}) {

package/src/installer/page.js

@@ -27,6 +27,35 @@ export const defaultStrings = Object.freeze({
   needsRepair: 'The desktop app updated itself, so {name} needs to be put back.',
   otherInstalled: '{other} is installed here. Uninstall it first.',
   connectionLost: 'The installer has stopped. Close this tab and run it again.',
+  // The Windows setup wizard
+  setupWelcomeTitle: 'Welcome to {name} Setup',
+  setupWelcomeText: 'Setup will install {name} {version} into the Yapin’ desktop app.',
+  setupContinue: 'Click Next to continue.',
+  setupChooseTitle: 'Choose an Option',
+  setupChooseSubtitle: 'Choose what Setup should do with {name}.',
+  setupInstall: 'Install {name} {version}',
+  setupUpdate: 'Update to {name} {version}',
+  setupReinstall: 'Reinstall {name} {version}',
+  setupRepair: 'Repair {name}',
+  setupUninstall: 'Uninstall {name}',
+  setupNotInstalled: 'Not installed. Click Install to continue.',
+  setupInstalledState: 'Installed:',
+  setupNeedsRepairState: 'Needs repair',
+  setupBlockedState: 'Can’t install here',
+  setupInstallingTitle: 'Installing',
+  setupInstallingText: 'Please wait while {name} is being installed.',
+  setupRepairingTitle: 'Repairing',
+  setupRepairingText: 'Please wait while {name} is being repaired.',
+  setupUninstallingTitle: 'Uninstalling',
+  setupUninstallingText: 'Please wait while {name} is being removed.',
+  setupDoneTitle: 'Completed',
+  setupDoneText: 'Setup finished.',
+  setupFailedTitle: 'Setup Failed',
+  setupFailedText: 'Nothing was changed. The details are below.',
+  setupFailed: 'The installer stopped with an error.',
+  setupStillRunning: '{product} is still open. Close it (check the system tray too), then click Next again.',
+  setupFinishTitle: 'Completing {name} Setup',
+  setupFinishText: 'Click Finish to close Setup.',
 });
 
 export function escapeHTML(text) {

package/src/installer/processes.js

@@ -6,36 +6,91 @@ function run(command, args) {
   });
 }
 
-/** Whether a process with this executable name is running. null if that can't be told. */
-export async function isRunning(processName, platform = process.platform) {
-  if (!processName) return null;
+/** One row of `tasklist /FO CSV`: comma-separated, double-quoted fields. */
+function parseCsvRow(line) {
+  return [...line.matchAll(/"((?:[^"]|"")*)"/g)].map((m) => m[1].replace(/""/g, '"'));
+}
+
+/**
+ * PIDs of every running process with this executable name, as numbers, excluding `excludePid` (the
+ * installer's own process, when it's running as the target app's own Node — see closeApp). null if
+ * that can't be told.
+ */
+async function matchingPids(processName, platform, excludePid) {
+  if (!processName) return [];
   if (platform === 'win32') {
     const out = await run('tasklist', ['/FI', `IMAGENAME eq ${processName}`, '/FO', 'CSV', '/NH']);
     if (out === null) return null;
-    return out.toLowerCase().includes(`"${processName.toLowerCase()}"`);
-  }
-  const out = await run('pgrep', ['-x', processName]);
-  if (out === null) {
-    const ps = await run('ps', ['-A', '-o', 'comm=']);
-    if (ps === null) return null;
-    return ps.split('\n').some((line) => line.trim().split('/').pop() === processName);
+    return out
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(parseCsvRow)
+      .filter(([name]) => name?.toLowerCase() === processName.toLowerCase())
+      .map(([, pid]) => Number(pid))
+      .filter((pid) => Number.isInteger(pid) && pid !== excludePid);
   }
-  return out.trim().length > 0;
+  const pgrep = await run('pgrep', ['-x', processName]);
+  const pids =
+    pgrep !== null
+      ? pgrep
+          .split('\n')
+          .map((s) => Number(s.trim()))
+          .filter(Number.isInteger)
+      : await (async () => {
+          const ps = await run('ps', ['-A', '-o', 'pid=,comm=']);
+          if (ps === null) return null;
+          return ps
+            .split('\n')
+            .map((line) => line.trim())
+            .filter(Boolean)
+            .map((line) => {
+              const match = /^(\d+)\s+(.*)$/.exec(line);
+              return match ? [Number(match[1]), match[2].split('/').pop()] : null;
+            })
+            .filter((row) => row && row[1] === processName)
+            .map(([pid]) => pid);
+        })();
+  return pids === null ? null : pids.filter((pid) => pid !== excludePid);
+}
+
+/**
+ * Whether a process with this executable name is running, other than `excludePid` (default: this
+ * process). That exclusion matters when the installer itself runs as the target app's own runtime
+ * (ELECTRON_RUN_AS_NODE), which makes the installer's own process share the app's executable name.
+ * null if that can't be told.
+ */
+export async function isRunning(processName, platform = process.platform, { excludePid = process.pid } = {}) {
+  const pids = await matchingPids(processName, platform, excludePid);
+  return pids === null ? null : pids.length > 0;
 }
 
-/** Closes every process with this executable name. Asks nicely first, then insists after `wait` ms. */
-export async function closeApp(processName, { platform = process.platform, wait = 5000 } = {}) {
-  if (platform === 'win32') await run('taskkill', ['/IM', processName]);
-  else await run('pkill', ['-x', processName]);
+/**
+ * Closes every process with this executable name except `excludePid` (default: this process). Asks
+ * nicely first (by PID, never a blanket kill-by-name), then insists after `wait` ms.
+ */
+export async function closeApp(processName, { platform = process.platform, wait = 5000, excludePid = process.pid } = {}) {
+  const killEach = async (force) => {
+    const pids = await matchingPids(processName, platform, excludePid);
+    for (const pid of pids ?? []) {
+      if (platform === 'win32') await run('taskkill', force ? ['/F', '/PID', String(pid)] : ['/PID', String(pid)]);
+      else {
+        try {
+          process.kill(pid, force ? 'SIGKILL' : 'SIGTERM');
+        } catch {
+          // already gone
+        }
+      }
+    }
+  };
+  await killEach(false);
   const deadline = Date.now() + wait;
   while (Date.now() < deadline) {
-    if (!(await isRunning(processName, platform))) return true;
+    if (!(await isRunning(processName, platform, { excludePid }))) return true;
     await new Promise((r) => setTimeout(r, 250));
   }
-  if (platform === 'win32') await run('taskkill', ['/F', '/IM', processName]);
-  else await run('pkill', ['-9', '-x', processName]);
+  await killEach(true);
   await new Promise((r) => setTimeout(r, 500));
-  return !(await isRunning(processName, platform));
+  return !(await isRunning(processName, platform, { excludePid }));
 }
 
 /** Starts the app, detached from the installer. */