nastechai-desktop 18.1.0

package/scripts/reload.mjs

@@ -0,0 +1,36 @@
+// Hard reload the Electron renderer over CDP. Vite-no-HMR mode means edits
+// don't auto-apply — call this after editing source.
+const targets = await (await fetch('http://127.0.0.1:9222/json')).json()
+const t = targets.find((t) => t.url.includes('5174'))
+if (!t) {
+  console.error('renderer not found')
+  process.exit(1)
+}
+const ws = new WebSocket(t.webSocketDebuggerUrl)
+let id = 0
+const pending = new Map()
+ws.addEventListener('message', (ev) => {
+  const m = JSON.parse(ev.data)
+  if (pending.has(m.id)) {
+    pending.get(m.id)(m)
+    pending.delete(m.id)
+  }
+})
+await new Promise((r) => ws.addEventListener('open', r))
+const send = (method, params = {}) =>
+  new Promise((res) => {
+    const i = ++id
+    pending.set(i, res)
+    ws.send(JSON.stringify({ id: i, method, params }))
+  })
+
+await send('Page.reload', { ignoreCache: true })
+console.log('reload sent')
+// Wait for new doc.
+await new Promise((r) => setTimeout(r, 2500))
+const r = await send('Runtime.evaluate', {
+  expression: 'JSON.stringify({ hasProbe: !!window.__PERF_PROBE__, composer: !!document.querySelector("[contenteditable=true]"), url: location.hash })',
+  returnByValue: true,
+})
+console.log(r.result.result.value)
+ws.close()

package/scripts/set-exe-identity.cjs

@@ -0,0 +1,94 @@
+#!/usr/bin/env node
+// set-exe-identity.cjs — stamp the NasTech icon + version metadata onto the
+// built NasTech.exe using rcedit, completely decoupled from electron-builder's
+// signing path.
+//
+// WHY THIS EXISTS
+// ---------------
+// apps/desktop/package.json sets build.win.signAndEditExecutable=false. That
+// flag is load-bearing: turning electron-builder's own exe-editing ON also
+// re-enables its signtool step, which fetches winCodeSign-2.6.0.7z, whose
+// macOS symlinks crash 7-Zip on non-admin Windows (no Developer Mode = no
+// SeCreateSymbolicLinkPrivilege). That is an unfixable dead end — we do NOT
+// try to extract winCodeSign.
+//
+// The cost of disabling signAndEditExecutable is that electron-builder also
+// skips rcedit, so the unpacked NasTech.exe keeps the stock Electron icon and
+// "Electron" taskbar name. This script restores the icon + identity by calling
+// rcedit DIRECTLY. rcedit is a pure PE resource editor: no signing, no certs,
+// no winCodeSign, no symlinks.
+//
+// HOW IT RUNS
+// -----------
+// Primarily as an electron-builder `afterPack` hook (scripts/after-pack.cjs),
+// so EVERY packed build — first install, `nastech desktop`, the installer's
+// --update rebuild, or a dev's manual `npm run pack` — gets a branded exe from
+// one place. Previously this stamp lived only in install.ps1, so the update
+// path (which rebuilds via `nastech desktop --build-only`, never install.ps1)
+// shipped a stock "Electron" exe. Keeping it in afterPack closes that gap.
+//
+// Also runnable standalone for ad-hoc re-stamping:
+//   node scripts/set-exe-identity.cjs <path-to-NasTech.exe>
+//
+// Exits 0 on success, non-zero on failure when run as a CLI. As a hook,
+// stampExeIdentity() resolves on success and rejects on failure; the caller
+// (after-pack.cjs) swallows the rejection so a stamp failure never fails an
+// otherwise-good build (worst case: stock icon, not a broken app).
+
+const path = require('node:path')
+const fs = require('node:fs')
+
+// Stamp the NasTech icon + identity onto `exe`. Resolves on success, throws on
+// failure. `desktopRoot` defaults to this script's package root so the icon and
+// the rcedit dependency resolve regardless of cwd.
+async function stampExeIdentity(exe, desktopRoot = path.resolve(__dirname, '..')) {
+  if (!exe || !fs.existsSync(exe)) {
+    throw new Error(`target exe not found: ${exe}`)
+  }
+
+  // Icon lives at apps/desktop/assets/icon.ico
+  const icon = path.join(desktopRoot, 'assets', 'icon.ico')
+  if (!fs.existsSync(icon)) {
+    throw new Error(`icon not found: ${icon}`)
+  }
+
+  // rcedit is a direct devDependency of apps/desktop, so it resolves whether
+  // we're run from the desktop dir or the repo root (workspace hoist).
+  // rcedit@5 exports a NAMED `rcedit` function (CommonJS: { rcedit }), not a
+  // default export.
+  const mod = require('rcedit')
+  const rcedit = typeof mod === 'function' ? mod : mod.rcedit
+  if (typeof rcedit !== 'function') {
+    throw new Error(`unexpected rcedit export shape: ${typeof mod} keys=${Object.keys(mod)}`)
+  }
+
+  console.log(`[set-exe-identity] stamping ${exe}`)
+  console.log(`[set-exe-identity] icon: ${icon}`)
+
+  await rcedit(exe, {
+    icon,
+    'version-string': {
+      ProductName: 'NasTech',
+      FileDescription: 'NasTech',
+      CompanyName: 'NasTech',
+      LegalCopyright: 'Copyright (c) 2026 NasTech'
+    }
+  })
+
+  console.log('[set-exe-identity] done — NasTech icon + identity stamped')
+}
+
+module.exports = { stampExeIdentity }
+
+// CLI entry point: `node scripts/set-exe-identity.cjs <exe>`.
+if (require.main === module) {
+  const exe = process.argv[2]
+  if (!exe) {
+    console.error('[set-exe-identity] usage: set-exe-identity.cjs <path-to-exe>')
+    process.exit(2)
+  }
+  stampExeIdentity(exe).catch(err => {
+    console.error(`[set-exe-identity] ${err.message}`)
+    process.exit(1)
+  })
+}

package/scripts/stage-native-deps.cjs

@@ -0,0 +1,159 @@
+'use strict'
+
+/**
+ * Stage native node-modules dependencies for electron-builder packaging.
+ *
+ * Workspace dedup hoists `node-pty` into the root `node_modules/`, which
+ * electron-builder's default file collector (when `files:` is explicitly set
+ * in package.json) cannot reach.  The result: packaged builds ship with no
+ * .node binaries and PTY initialization fails at runtime ("PTY support is
+ * unavailable").
+ *
+ * Rather than restructure the workspace dedup (would require nohoist /
+ * package.json shenanigans and risk breaking dev) or balloon the package
+ * with the whole node_modules tree, we copy ONLY the runtime-essential
+ * files of the native dep into apps/desktop/build/native-deps/ and ship
+ * THAT subtree via extraResources.  main.cjs falls back to require()-ing
+ * from process.resourcesPath when the hoisted-root require fails.
+ *
+ * Runs as part of `npm run build`. Idempotent -- always re-stages on each
+ * build to pick up native binary updates.
+ *
+ * Layout note: upstream node-pty (microsoft/node-pty 1.x) is N-API based
+ * and ships its prebuilts under `prebuilds/<platform>-<arch>/` instead of
+ * `build/Release/`.  Its runtime resolver (lib/utils.js) checks
+ * build/Release first and falls through to the per-arch prebuilds dir, so
+ * shipping only the latter is sufficient for packaged runs.  Per-arch
+ * staging keeps the resource bundle lean -- we only need the target
+ * arch's prebuilt, not all of them.
+ */
+
+const fs = require('node:fs')
+const path = require('node:path')
+
+const APP_ROOT = path.resolve(__dirname, '..')
+const REPO_ROOT = path.resolve(APP_ROOT, '..', '..')
+const STAGE_ROOT = path.join(APP_ROOT, 'build', 'native-deps')
+
+// The target arch may be overridden by electron-builder via npm_config_arch
+// (e.g. `npm run dist -- --arm64`); fall back to the build host's arch.
+const TARGET_ARCH = process.env.npm_config_arch || process.arch
+const TARGET_PLATFORM = process.platform
+
+// Modules to stage. The "from" path is the hoisted location in the workspace
+// root; "to" is the layout we want inside build/native-deps/.  The "include"
+// globs (relative to "from") select the runtime-essential files.  Anything
+// outside the include list is left behind (source, deps/, scripts/, etc.).
+const NATIVE_DEPS = [
+  {
+    from: path.join(REPO_ROOT, 'node_modules', 'node-pty'),
+    to: path.join(STAGE_ROOT, 'node-pty'),
+    include: [
+      'package.json',
+      'lib/*.js',
+      'lib/**/*.js',
+      'build/Release/*.node',
+      // Per-arch runtime payload. Explicit file types so we don't ship the
+      // ~25 MB of .pdb debug symbols that prebuild-install bundles for
+      // Windows crash analysis -- not used at runtime, would just bloat
+      // the installer.
+      `prebuilds/${TARGET_PLATFORM}-${TARGET_ARCH}/*.node`,
+      `prebuilds/${TARGET_PLATFORM}-${TARGET_ARCH}/*.dll`,
+      `prebuilds/${TARGET_PLATFORM}-${TARGET_ARCH}/*.exe`,
+      `prebuilds/${TARGET_PLATFORM}-${TARGET_ARCH}/spawn-helper`,
+      `prebuilds/${TARGET_PLATFORM}-${TARGET_ARCH}/conpty/*`
+    ]
+  }
+]
+
+function rmrf(target) {
+  fs.rmSync(target, { recursive: true, force: true })
+}
+
+function ensureDir(target) {
+  fs.mkdirSync(target, { recursive: true })
+}
+
+function walk(root) {
+  const results = []
+  const stack = [root]
+  while (stack.length) {
+    const current = stack.pop()
+    let entries
+    try {
+      entries = fs.readdirSync(current, { withFileTypes: true })
+    } catch {
+      continue
+    }
+    for (const entry of entries) {
+      const full = path.join(current, entry.name)
+      if (entry.isDirectory()) {
+        stack.push(full)
+      } else if (entry.isFile()) {
+        results.push(full)
+      }
+    }
+  }
+  return results
+}
+
+// Match a relative path against simple ** and * glob patterns. Implementation
+// is intentionally tiny -- the include lists are small and don't need full
+// minimatch support.
+function matchGlob(rel, pattern) {
+  const r = rel.replace(/\\/g, '/')
+  const re = new RegExp(
+    '^' +
+      pattern
+        .replace(/\\/g, '/')
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&')
+        .replace(/\*\*/g, '__DOUBLE_STAR__')
+        .replace(/\*/g, '[^/]*')
+        .replace(/__DOUBLE_STAR__/g, '.*') +
+      '$'
+  )
+  return re.test(r)
+}
+
+function stageOne(spec) {
+  if (!fs.existsSync(spec.from)) {
+    throw new Error(
+      `stage-native-deps: source missing at ${spec.from}.  Run \`npm install\` ` +
+        `at the workspace root first.`
+    )
+  }
+  rmrf(spec.to)
+  ensureDir(spec.to)
+
+  const files = walk(spec.from)
+  let copied = 0
+  for (const abs of files) {
+    const rel = path.relative(spec.from, abs)
+    const included = spec.include.some(g => matchGlob(rel, g))
+    if (!included) continue
+    const dest = path.join(spec.to, rel)
+    ensureDir(path.dirname(dest))
+    fs.copyFileSync(abs, dest)
+    // node-pty's darwin spawn-helper and the Windows helper binaries
+    // (OpenConsole.exe, winpty-agent.exe) are invoked via posix_spawn /
+    // CreateProcess at runtime, so they must remain executable in the
+    // staged tree.  fs.copyFileSync preserves source mode on POSIX, but we
+    // re-assert +x defensively for the darwin spawn-helper (no extension
+    // means a stripped mode would be silently broken at runtime).
+    if (path.basename(rel) === 'spawn-helper' && process.platform !== 'win32') {
+      try { fs.chmodSync(dest, 0o755) } catch { /* best-effort */ }
+    }
+    copied += 1
+  }
+  console.log(`[stage-native-deps] ${path.relative(APP_ROOT, spec.to)}: ${copied} files`)
+}
+
+function main() {
+  rmrf(STAGE_ROOT)
+  ensureDir(STAGE_ROOT)
+  for (const spec of NATIVE_DEPS) {
+    stageOne(spec)
+  }
+}
+
+main()