π OpenHands: AI-Driven Development
feat: add electron desktop app (#1864)
Hiep Le4e9ea1334ada
diff --git a/.gitignore b/.gitignoreindex 182f1ca650..a66c0a039b 100644--- a/.gitignore+++ b/.gitignore@@ -32,3 +32,10 @@ ralph/# Local runtime artifacts produced by static-server / agent-server runsworkspace/build-fresh/++# Electron desktop build outputs+/dist-electron/+# Downloaded uv binary (populated by `npm run download-uv` before packaging)+/resources/bin/+# Downloaded Node.js distribution (populated by `npm run download-node` before packaging)+/resources/node/diff --git a/AGENTS.md b/AGENTS.mdindex 021c9c54a5..7567b39c01 100644--- a/AGENTS.md+++ b/AGENTS.md@@ -648,4 +648,14 @@ When adding code that needs a new string, decide up front which rule it falls un- Release automation: releases are **trunk-based via release-please**, using the shared reusable workflows from [`OpenHands/release-actions`](https://github.com/OpenHands/release-actions) through three thin callers: `.github/workflows/release.yml` (runs release-please on every push to `main` / `release/**`; maintains a draft `chore(main): release X.Y.Z` PR that accumulates merged changes and pre-stages every version bump), `.github/workflows/pr.yml` (lints PR titles for Conventional Commits under `pull_request_target` β never checks out PR code and must NOT get `secrets: inherit` β and applies the `type:` labels that drive release-notes grouping via `.github/release.yml`), and `.github/workflows/release-ready.yml` (marking the draft release PR **Ready for review** is the cut-a-release signal: Slack notification to `#proj-agent-canvas` + `release: ready` label). Config lives in `release-please-config.json` β node release-type (bumps `package.json` + `package-lock.json`) plus `extra-files` keeping `config/defaults.json` `versions.agentCanvas` and the README / README.windows Docker image pins (lines annotated `x-release-please-version`) in lockstep β and `.release-please-manifest.json` (current released version). There is no `CHANGELOG.md`; GitHub Releases are the changelog. Merging the release PR pushes the `vX.Y.Z` tag with the org release App token (`RELEASE_APP_ID` / `RELEASE_APP_PRIVATE_KEY` β required so the tag push fires downstream workflows; a `GITHUB_TOKEN` push would be suppressed) and creates the GitHub Release; the same tag push triggers `npm-publish.yml` (dist-tag resolved dynamically at publish time β stable versions get `latest`) and `docker.yml` (multi-arch images + semver tags). Version derivation: `fix` β patch, `feat` β minor, `!`/`BREAKING CHANGE` β major; other types don't produce a release PR. The release skill (`.agents/skills/release.md`, keyword trigger: `release`) guides agents through the full process.+- Electron desktop app (`npm run desktop` for dev / `npm run build:desktop` for the binary) starts the same stack as `dev-with-automation.mjs` but inside an Electron BrowserWindow. Two gotchas live here:++ 1. **Boot race vs. agent-server cold start**: `dev-with-automation.mjs` is a fire-and-forget launcher β `main()` previously returned as soon as `waitForService` saw the ingress proxy respond on `/api/health`, but ingress responds immediately while the agent-server behind it can still be downloading via `uvx` (first run pulls ~50 MB of Python + the SDK from PyPI, easily 30β90s). `electron/main.mjs` used to load the URL as soon as the proxy responded, so the React app booted, called `/server_info`, and got the "Request timeout" popup. Fix: `main()` now accepts an `agentServerReadyTimeoutMs` option and returns `{ config, agentServerReady }`; `electron/main.mjs` runs a two-stage wait β Stage 1 (`waitForUrl`) confirms the ingress proxy is up, Stage 2 (`waitForAgentServer`) hits `${ingress}/server_info` and only accepts `200` (or `401`, which proves the proxy reached a real agent-server) before the BrowserWindow loads. Don't shorten the agent-server timeout below ~3 min β uvx cold start on slow connections genuinely takes that long.++ 2. **First-run feedback loop**: `dev-with-automation.mjs::setServiceLogListener(cb)` exposes a workspace-wide hook that fires `cb(name, line, level)` for every line of every child-process stdout/stderr/exit. `electron/main.mjs::handleServiceLog` filters for uvx install lines (`Downloading...`, `Resolved N packages...`, etc.) plus agent-server boot markers and forwards them to `loading.html` via `setLoadingStatus()` β `window.__setLoadingStatus()`. The hook is best-effort and swallows listener errors β a buggy embedder must not be able to take down the dev stack.++- Electron desktop packaging β `electron-builder.config.mjs` uses `directories.app: "electron"` so electron/package.json is the app manifest. Even though electron/package.json has zero `dependencies`, app-builder-lib's `collectNodeModulesWithLogging` walks UP from the app dir looking for the first npm workspace that resolves modules. The next dir in line is the project root, where `npm list --json` reports the full hoisted tree (~342 dirs, ~600 MB of Vite/React/Monaco/HeroUI), and electron-builder copies all of it into `Resources/app/node_modules/`. The walk is hardcoded in `app-builder-lib/out/util/appFileCopier.js::collectNodeModulesWithLogging` β there is no config knob to disable it. Creating an empty `electron/node_modules/` does NOT help because the collector falls through to project root when it sees zero deps. **The fix is the `afterPack` hook** (`stripBundledNodeModules` in `electron-builder.config.mjs`): after electron-builder copies everything, the hook `rm -rf`s `Resources/app/node_modules/` (handling macOS `.app` bundle layout and Linux/Windows flat resources/ layout), then copies back the dependency closure of `RUNTIME_PACKAGES` (`sirv` for static-server.mjs, `httpxy` for proxy-utils.mjs/ingress.mjs β ~200 KB total). Effect: `resources/app/` drops from ~598 MB to ~7 MB; total `linux-unpacked/` from ~1 GB to ~365 MB (the rest is Electron + Chromium + the bundled `uv` binary). If a spawned backend script gains a new bare npm import, add the package to `RUNTIME_PACKAGES` β otherwise that service crashes with `ERR_MODULE_NOT_FOUND` only in the installed app. **Testing trap:** an app launched from `dist-electron/` inside the repo resolves bare specifiers against the repo's own `node_modules` (Node ESM resolution walks up from the script file), so a missing runtime package is invisible there β verify packaged builds from a copy outside the repo tree (e.g. `/Applications`). Don't add real deps to electron/package.json β any real dep would survive the strip and would also have to be hand-installed inside electron/ since the project root is npm-hoisted. `build:desktop:universal` and `--linux/--win/--mac` variants all run the same hook.++- Electron desktop `node` / `npm` / `npx` PATH bridging β when the packaged `.app` is launched from Finder/Spotlight on macOS, the OS gives it a minimal PATH (`/usr/bin:/bin`). Homebrew, nvm, asdf installs of Node.js are invisible to spawned subprocesses. Two breakages flow from that: (1) backend launcher scripts that do `spawn("node", ...)` can't find Node; (2) most stdio MCP marketplace entries (Slack, GitHub, Figma, etc.) use `command: "npx"`, and when the agent-server tries to spawn them the missing `npx` makes the spawn fail with ENOENT β the SDK reports it as an `error_kind: "connection"` MCP test failure, which the install modal renders as `MCP$TEST_ERROR_CONNECTION` ("Could not reach the server. Check the URL and server type."), a misleading error since no URL is involved. **First fix attempt β DOES NOT WORK for stdio MCPs:** wrap `node`/`npm`/`npx` with thin shell scripts that run Electron with `ELECTRON_RUN_AS_NODE=1` against the package's CLI JS. That bridges the ENOENT but stdio JSON-RPC servers spawned through the wrapper exit with `McpError: Connection closed` before completing the MCP handshake β Electron-as-Node has subtly different stdin/stdout pipe semantics from a vanilla `node` binary when used as a stdio child of a windowed process. **Working fix:** bundle the real Node.js distribution. `scripts/download-node.mjs` downloads the official `node-v<ver>-<platform>-<arch>` tarball from `https://nodejs.org/dist/v<ver>/` into `resources/node/` (gitignored), prunes `include/`, `share/`, docs, and `node_modules/corepack` to keep the size down (~130 MB on Linux x64, dominated by the Node binary itself). Default pin: `NODE_BUNDLE_VERSION = "22.12.0"` (the repo's `engines.node` floor; every 22.x build shares the Electron 42 ABI); override with `NODE_VERSION=`. `electron-builder.config.mjs` ships `resources/node/` as an extraResource β `<Resources>/node/`. `electron/main.mjs::injectBundledNode()` prepends the platform-appropriate bin dir to `PATH` (POSIX: `<Resources>/node/bin`; Windows: `<Resources>/node/`) so subsequent spawns of `node`/`npm`/`npx` resolve to real binaries with full stdio fidelity. It also `chmod +x`'s the binaries on POSIX because electron-builder doesn't always preserve the bit. `injectBundledNode()` is a no-op when `!app.isPackaged` (dev `npm run desktop` uses the developer's system node). `build:desktop` and `build:desktop:universal` both run `download-node.mjs` after `download-uv.mjs`. If the bundled dir is missing at runtime, `injectBundledNode()` logs a loud `[desktop]` warning instead of silently leaving PATH bare.+- Cloud conversation resume gating: when a cloud conversation is closed from the UI (`pauseCloudSandbox` is called), the conversation's `conversation_url` is NOT cleared -- it still points to the old sandbox host. `WebSocketProviderWrapper` must suppress the URL (pass `null` to `ConversationWebSocketProvider`) while `sandbox_status === "PAUSED"`, otherwise the WebSocket immediately tries the stale URL before the sandbox wakes. Symmetrically, `useActiveConversation`'s refetch interval must fast-poll (3 s) on both `!conversation_url` AND `sandbox_status === "PAUSED"` -- checking only the missing URL would leave the hook on the 30 s interval while the sandbox is resuming. The resume sequence: navigate -> sandbox PAUSED detected -> `resumeCloudSandbox` called (in `conversation.tsx`) -> fast-poll detects RUNNING -> `conversationUrl` unblocked -> WebSocket connects.diff --git a/__tests__/api/agent-server-conversation-service.test.ts b/__tests__/api/agent-server-conversation-service.test.tsindex a7000e95ae..66d221c133 100644--- a/__tests__/api/agent-server-conversation-service.test.ts+++ b/__tests__/api/agent-server-conversation-service.test.ts@@ -268,6 +268,9 @@ describe("AgentServerConversationService", () => {host: "http://localhost:54928",apiKey: "test-api-key",workingDir: "/workspace/project/agent-canvas",+ // See CREATE_CONVERSATION_TIMEOUT_MS in the service module: first+ // conversation on a cold agent-server boot exceeds the 60s default.+ timeout: 5 * 60 * 1000,});expect(mockHttpPost).toHaveBeenCalledTimes(2);const [firstCall, secondCall] = mockHttpPost.mock.calls;diff --git a/__tests__/scripts/dev-with-automation.test.ts b/__tests__/scripts/dev-with-automation.test.tsindex 7b662580cb..bfddad4628 100644--- a/__tests__/scripts/dev-with-automation.test.ts+++ b/__tests__/scripts/dev-with-automation.test.ts@@ -22,6 +22,8 @@ import {buildViteBackendEnv,getFrontendBackend,getLocalServiceRoutes,+ setServiceLogListener,+ spawnService,DEFAULT_AUTOMATION_REPO,DEFAULT_AUTOMATION_PACKAGE,DEFAULT_AUTOMATION_VERSION,@@ -498,6 +500,95 @@ describe("default constants", () => {});});+describe("setServiceLogListener", () => {+ afterEach(() => {+ // Always clear the listener so it doesn't leak between tests.+ setServiceLogListener(null);+ });++ it("forwards stdout, stderr, and exit lines to the listener", async () => {+ const captured: Array<{ name: string; line: string; level: string }> = [];+ setServiceLogListener((name: string, line: string, level: string) => {+ captured.push({ name, line, level });+ });++ // Spawn a tiny inline script that writes to stdout, stderr, and exits+ // non-zero so we exercise all three log paths. `process.execPath` is+ // the same Node binary running the test so this is portable.+ const proc = spawnService(+ "log-listener-test",+ process.execPath,+ [+ "-e",+ // Use double-quoted JS to avoid shell quoting differences.+ 'process.stdout.write("hello-stdout\\n"); process.stderr.write("hello-stderr\\n"); process.exit(2);',+ ],+ {},+ );++ await once(proc, "exit");+ // Give the stdout/stderr 'data' handlers and the exit handler a tick to+ // run after the process has actually exited.+ await delay(50);++ const lines = captured.map((c) => `${c.level}:${c.line}`);+ expect(lines).toContain("stdout:hello-stdout");+ expect(lines).toContain("stderr:hello-stderr");+ expect(lines).toContain("error:exited with code 2");++ // Every captured line must be tagged with our service name.+ expect(captured.every((c) => c.name === "log-listener-test")).toBe(true);+ });++ it("is a no-op once the listener is cleared", async () => {+ const captured: string[] = [];+ setServiceLogListener((_n: string, line: string) => captured.push(line));+ setServiceLogListener(null);++ const proc = spawnService(+ "log-listener-clear-test",+ process.execPath,+ ["-e", 'process.stdout.write("should-not-be-seen\\n");'],+ {},+ );++ await once(proc, "exit");+ await delay(50);++ expect(captured).toHaveLength(0);+ });++ it("ignores non-function values without throwing", () => {+ // Passing anything that isn't a function (undefined, null, a string) must+ // be safe β main() relies on this so it can always call+ // setServiceLogListener(onServiceLog) regardless of whether the embedder+ // supplied a callback.+ expect(() => setServiceLogListener(undefined)).not.toThrow();+ expect(() => setServiceLogListener(null)).not.toThrow();+ expect(() => setServiceLogListener("not a function")).not.toThrow();+ });++ it("swallows errors thrown by the listener so a buggy embedder cannot kill the dev stack", async () => {+ // A listener that throws on every call must not propagate; the stdout+ // handler in spawnService is fire-and-forget. We can't easily observe+ // an unhandled rejection from within Vitest, but if we can run a process+ // to completion without the test failing, the catch is doing its job.+ setServiceLogListener(() => {+ throw new Error("buggy listener");+ });++ const proc = spawnService(+ "log-listener-throws-test",+ process.execPath,+ ["-e", 'process.stdout.write("line\\n"); process.exit(0);'],+ {},+ );++ const [code] = await once(proc, "exit");+ expect(code).toBe(0);+ });+});+describe("dev-with-automation CLI", () => {it("shows help with --help flag", async () => {const child = spawn(diff --git a/__tests__/scripts/electron-builder-config.test.ts b/__tests__/scripts/electron-builder-config.test.tsnew file mode 100644index 0000000000..53571f0e85--- /dev/null+++ b/__tests__/scripts/electron-builder-config.test.ts@@ -0,0 +1,98 @@+// @vitest-environment node+// The afterPack hook manipulates real directories and its contract is that+// the packaged app's spawned servers can resolve their bare npm imports+// (sirv, httpxy) OUTSIDE a repo checkout β Node's ESM resolution walks up+// from the importing file, so a bundle tested inside the repo silently+// resolves against the repo's node_modules and hides a missing package.+// These tests therefore build a fake bundle under os.tmpdir() and verify+// resolution with a real `node --eval` from that location.+import { spawnSync } from "node:child_process";+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { afterEach, describe, expect, it } from "vitest";+import config from "../../electron-builder.config.mjs";++const afterPack = config.afterPack as (ctx: unknown) => Promise<void>;++const PRODUCT_FILENAME = "Agent Canvas";++function makeContext(platform: string, appOutDir: string) {+ return {+ electronPlatformName: platform,+ appOutDir,+ packager: { appInfo: { productFilename: PRODUCT_FILENAME } },+ };+}++/** Resolve the packaged app dir for a platform, mirroring the bundle layout. */+function appDirFor(platform: string, appOutDir: string) {+ return platform === "darwin"+ ? join(appOutDir, `${PRODUCT_FILENAME}.app`, "Contents", "Resources", "app")+ : join(appOutDir, "resources", "app");+}++/**+ * Run `await import("sirv"); await import("httpxy")` with a real Node+ * process whose cwd is the packaged app dir β exactly how the spawned+ * static-server/ingress scripts resolve their imports at runtime.+ */+function resolveRuntimeImports(appDir: string) {+ return spawnSync(+ process.execPath,+ ["--input-type=module", "-e", 'await import("sirv"); await import("httpxy");'],+ { cwd: appDir, stdio: "pipe" },+ );+}++describe("electron-builder afterPack hook", () => {+ let tmp: string | null = null;++ afterEach(() => {+ if (tmp) rmSync(tmp, { recursive: true, force: true });+ tmp = null;+ });++ it("strips the auto-bundled node_modules and restores a resolvable runtime closure (macOS layout)", async () => {+ tmp = mkdtempSync(join(tmpdir(), "eb-afterpack-"));+ const appDir = appDirFor("darwin", tmp);+ // Simulate electron-builder's accidental copy of the hoisted dev tree.+ const junkPkg = join(appDir, "node_modules", "react");+ mkdirSync(junkPkg, { recursive: true });+ writeFileSync(join(junkPkg, "package.json"), '{"name":"react"}');++ await afterPack(makeContext("darwin", tmp));++ expect(existsSync(junkPkg)).toBe(false);+ const result = resolveRuntimeImports(appDir);+ expect(result.status, String(result.stderr)).toBe(0);+ });++ it("restores the runtime closure even when no node_modules was bundled", async () => {+ // If electron-builder ever stops copying the hoisted tree, the restore+ // must still run β otherwise the installed app regresses to+ // ERR_MODULE_NOT_FOUND in ingress/static-server.+ tmp = mkdtempSync(join(tmpdir(), "eb-afterpack-"));+ const appDir = appDirFor("darwin", tmp);+ mkdirSync(appDir, { recursive: true });++ await afterPack(makeContext("darwin", tmp));++ const result = resolveRuntimeImports(appDir);+ expect(result.status, String(result.stderr)).toBe(0);+ });++ it("operates on the flat resources/app layout for non-mac platforms", async () => {+ tmp = mkdtempSync(join(tmpdir(), "eb-afterpack-"));+ const appDir = appDirFor("linux", tmp);+ const junkPkg = join(appDir, "node_modules", "react");+ mkdirSync(junkPkg, { recursive: true });+ writeFileSync(join(junkPkg, "package.json"), '{"name":"react"}');++ await afterPack(makeContext("linux", tmp));++ expect(existsSync(junkPkg)).toBe(false);+ expect(existsSync(join(appDir, "node_modules", "sirv", "package.json"))).toBe(true);+ expect(existsSync(join(appDir, "node_modules", "httpxy", "package.json"))).toBe(true);+ });+});diff --git a/__tests__/scripts/logger.test.ts b/__tests__/scripts/logger.test.tsnew file mode 100644index 0000000000..23362eeb67--- /dev/null+++ b/__tests__/scripts/logger.test.ts@@ -0,0 +1,32 @@+// @vitest-environment node+// scripts/logger.mjs treats winston as optional: the packaged Electron+// desktop app ships without the dev node_modules tree, so the dynamic+// winston import fails there and file logging must degrade to a no-op+// instead of crashing every script that calls fileLog().+import { existsSync } from "node:fs";+import { tmpdir } from "node:os";+import { join } from "node:path";+import { afterEach, describe, expect, it, vi } from "vitest";++vi.mock("winston", () => {+ throw new Error("winston is not installed in the packaged app");+});+vi.mock("winston-daily-rotate-file", () => {+ throw new Error("winston-daily-rotate-file is not installed in the packaged app");+});++describe("logger without winston", () => {+ afterEach(() => {+ vi.unstubAllEnvs();+ });++ it("fileLog is a safe no-op that creates no log directory", async () => {+ const stateDir = join(tmpdir(), `logger-test-${process.pid}`);+ vi.stubEnv("OH_CANVAS_SAFE_STATE_DIR", stateDir);++ const { fileLog } = await import("../../scripts/logger.mjs");++ expect(() => fileLog("info", "hello from the packaged app")).not.toThrow();+ expect(existsSync(join(stateDir, "logs"))).toBe(false);+ });+});diff --git a/electron-builder.config.mjs b/electron-builder.config.mjsnew file mode 100644index 0000000000..5131e3ebd5--- /dev/null+++ b/electron-builder.config.mjs@@ -0,0 +1,327 @@+/**+ * electron-builder configuration for the Agent Canvas desktop app.+ *+ * `directories.app: 'electron'` tells electron-builder to use electron/package.json+ * as the app manifest (with `"main": "main.mjs"`). This sidesteps the root+ * package.json's `"main": "./dist/index.cjs"` without any afterPack patching.+ *+ * NODE_MODULES NOTE:+ *+ * Even with zero `dependencies` in electron/package.json, electron-builder's+ * "search for node modules" routine walks UP from directories.app looking+ * for the first node_modules in scope. It runs `npm list --json` in the+ * project root, gets the full hoisted tree (~342 dirs, ~600 MB: Vite,+ * React, Monaco, HeroUI, etc.), and copies all of it into the packaged+ * app at Resources/app/node_modules/.+ *+ * Almost none of those packages are imported at desktop runtime β main.mjs+ * and the launcher (dev-with-automation.mjs) use only Node built-ins. The+ * exception is the two child-process servers: static-server.mjs imports+ * `sirv` and ingress.mjs (via proxy-utils.mjs) imports `httpxy`. Node+ * resolves those bare specifiers by walking UP from the script's own path,+ * so an app tested from dist-electron/ inside a repo checkout accidentally+ * resolves them against the repo's node_modules and works β while the same+ * app in /Applications crashes both servers with ERR_MODULE_NOT_FOUND and+ * the splash times out waiting for port 8000. We can't disable the search+ * from the config (it's hardcoded in app-builder-lib), and creating an+ * empty electron/node_modules/ doesn't help because `npm list` from the+ * project root still reports the full hoisted tree.+ *+ * The fix is the `afterPack` hook below: after electron-builder has+ * finished copying files, we rm -rf the bundled Resources/app/node_modules/+ * directory, then copy back the dependency closure of RUNTIME_PACKAGES+ * (~200 KB). The build wastes a few seconds copying files we immediately+ * delete, but the final artifact is correctly tiny (~10 MB vs ~600 MB).+ *+ * Packaged app layout (Resources/app/ = electron/ contents):+ * main.mjs β Electron entry point+ * loading.html β loading splash+ * package.json β {"main":"main.mjs"} (from electron/package.json)+ * scripts/ β backend scripts+ * node_modules/ β runtime closure of RUNTIME_PACKAGES (restored by afterPack)+ * config/ β defaults.json+ * build/ β static frontend (npm run build:app output)+ *+ * The bundled uv binary (resources/bin/) lands in <Resources>/bin/ via+ * extraResources so Electron can inject it into PATH on startup.+ *+ * The bundled Node.js distribution (resources/node/) lands in+ * <Resources>/node/ via extraResources. Electron prepends its bin dir to+ * PATH at startup so backend scripts (`node scripts/ingress.mjs` etc.) and+ * stdio MCP servers spawned via `npx -y β¦` (Slack, GitHub, Figma, etc.)+ * can find a working node/npm/npx β the OS gives a Finder-launched .app+ * a minimal PATH (/usr/bin:/bin) that has none of those.+ */++import { cp, rm } from "node:fs/promises";+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";+import { dirname, join, relative } from "node:path";+import { fileURLToPath } from "node:url";++// npm packages the packaged app's child-process scripts import at runtime:+// scripts/static-server.mjs β sirv+// scripts/proxy-utils.mjs β httpxy (imported by ingress.mjs)+// Their dependency closure is copied back into Resources/app/node_modules+// after the strip below. If a spawned script gains a new bare import, add+// the package here β a missing one crashes that service in the installed+// app with ERR_MODULE_NOT_FOUND (invisible under Finder, where stdout goes+// to /dev/null) and the splash times out waiting for port 8000.+const RUNTIME_PACKAGES = ["sirv", "httpxy"];++const repoRoot = dirname(fileURLToPath(import.meta.url));++/**+ * Strip the auto-bundled node_modules from the packaged app, then restore+ * the small runtime closure of RUNTIME_PACKAGES.+ *+ * See the NODE_MODULES NOTE in the file header for the why. This is invoked+ * by electron-builder once per platform target after the unpacked directory+ * has been populated but before installer-format packaging (DMG, NSIS, deb).+ *+ * On macOS the app dir is inside a `.app` bundle; on Linux/Windows it's a+ * flat resources/ subdirectory. We resolve both shapes from+ * `context.appOutDir` + the productFilename.+ */+async function stripBundledNodeModules(context) {+ const platform = context.electronPlatformName;+ const productFilename = context.packager.appInfo.productFilename;+ const appDir =+ platform === "darwin" || platform === "mas"+ ? join(+ context.appOutDir,+ `${productFilename}.app`,+ "Contents",+ "Resources",+ "app",+ )+ : join(context.appOutDir, "resources", "app");++ const nm = join(appDir, "node_modules");+ if (existsSync(nm)) {+ // Best-effort size report so the log line shows what we saved. Skip if+ // walking the tree fails for any reason β the rm below is what matters.+ let sizeMb = null;+ try {+ sizeMb = Math.round(getDirSizeBytes(nm) / (1024 * 1024));+ } catch {}++ await rm(nm, { recursive: true, force: true });++ const rel = relative(process.cwd(), nm);+ const human = sizeMb != null ? ` (~${sizeMb} MB)` : "";+ // eslint-disable-next-line no-console -- electron-builder build log+ console.log(+ `[electron-builder] stripped bundled node_modules${human}: ${rel}`,+ );+ }++ await restoreRuntimeNodeModules(appDir);+}++/**+ * Copy the dependency closure of RUNTIME_PACKAGES from the repo's+ * node_modules into the packaged app's Resources/app/node_modules so the+ * spawned `node scripts/β¦` servers can resolve their bare imports outside+ * a repo checkout (see RUNTIME_PACKAGES above).+ *+ * Resolution is deliberately simple: every package (and every transitive+ * `dependencies` entry) is looked up at the repo root's flat npm tree, and+ * a miss throws so the build fails loudly instead of shipping a DMG whose+ * ingress/static-server crash on launch.+ */+async function restoreRuntimeNodeModules(appDir) {+ const rootNodeModules = join(repoRoot, "node_modules");++ // name β source dir, walking `dependencies` breadth-first.+ const packages = new Map();+ const queue = [...RUNTIME_PACKAGES];+ while (queue.length) {+ const name = queue.shift();+ if (packages.has(name)) continue;+ const srcDir = join(rootNodeModules, ...name.split("/"));+ const manifestPath = join(srcDir, "package.json");+ if (!existsSync(manifestPath)) {+ throw new Error(+ `[electron-builder] runtime package "${name}" not found in ` ++ `${rootNodeModules} β run npm install and rebuild`,+ );+ }+ packages.set(name, srcDir);+ const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));+ queue.push(...Object.keys(manifest.dependencies ?? {}));+ }++ let totalBytes = 0;+ for (const [name, srcDir] of packages) {+ const destDir = join(appDir, "node_modules", ...name.split("/"));+ await cp(srcDir, destDir, { recursive: true });+ totalBytes += getDirSizeBytes(destDir);+ }++ // eslint-disable-next-line no-console -- electron-builder build log+ console.log(+ `[electron-builder] restored runtime node_modules ` ++ `(${[...packages.keys()].join(", ")}; ~${Math.round(totalBytes / 1024)} KB)`,+ );+}++function getDirSizeBytes(dir) {+ // Synchronous walk so we can run it before the rm without async juggling+ // in the hook. The directory we're sizing is always small enough (<1 GB)+ // that this is negligible compared to the rm itself.+ let total = 0;+ const stack = [dir];+ while (stack.length) {+ const next = stack.pop();+ let entries;+ try {+ entries = readdirSync(next, { withFileTypes: true });+ } catch {+ // Best-effort: skip unreadable dirs (symlink races, permission+ // errors on platform-specific node_modules subtrees, etc.). The+ // size number is only used in a build-log line, so under-counting+ // is preferable to aborting the strip.+ continue;+ }+ for (const entry of entries) {+ const p = join(next, entry.name);+ if (entry.isDirectory()) {+ stack.push(p);+ } else {+ try {+ total += statSync(p).size;+ } catch {}+ }+ }+ }+ return total;+}++/** @type {import('electron-builder').Configuration} */+const config = {+ appId: "dev.openhands.agent-canvas",+ productName: "Agent Canvas",+ copyright: "Copyright Β© 2025 All Hands AI",++ // Treat electron/ as the app root. electron/package.json provides the+ // Electron entry point without touching the npm-published root package.json.+ // `buildResources` points at electron/build-resources so electron-builder+ // can auto-discover icon.png (1024Γ1024 OpenHands raised-hands app icon)+ // and generate the platform-specific icon.icns / icon.ico from it.+ directories: {+ app: "electron",+ output: "dist-electron",+ buildResources: "electron/build-resources",+ },++ // Do not pack into asar β scripts are spawned as child processes by+ // dev-with-automation.mjs and must exist as real files on disk.+ asar: false,++ // Skip native-module rebuild β the app has no native deps.+ npmRebuild: false,++ // Strip auto-bundled node_modules (see NODE_MODULES NOTE at top of file).+ afterPack: stripBundledNodeModules,++ // Files included in the packaged app.+ // Paths with `from` are relative to directories.app (electron/).+ // Bare globs are also relative to directories.app.+ files: [+ // electron/ base files (main.mjs, loading.html, package.json)+ "**/*",+ // Bundle the raw 1024Γ1024 PNG into Resources/app/build-resources/ so+ // main.mjs can set it as the BrowserWindow icon at runtime (used for the+ // Linux taskbar; macOS reads from the .icns inside the .app bundle).+ "build-resources/icon.png",+ // Scripts from project root. Mostly Node built-ins; the two spawned+ // servers additionally need RUNTIME_PACKAGES, restored into+ // Resources/app/node_modules by the afterPack hook.+ { from: "../scripts", to: "scripts", filter: ["**/*.mjs", "**/*.cjs"] },+ // Centralised version / port / path config+ { from: "../config", to: "config" },+ // Pre-built static frontend (npm run build:app output)+ { from: "../build", to: "build" },+ // Custom Python tools (canvas_ui_tool.py). dev-safe.mjs sets+ // OH_EXTRA_PYTHON_PATH to this directory so the agent-server can import+ // canvas_ui_tool at runtime. The path is computed as ../tools relative to+ // scripts/dev-safe.mjs, which resolves correctly in both dev and packaged mode.+ { from: "../tools", to: "tools" },+ ],++ // Bundled prerequisites β placed in <Resources>/ so Electron can put+ // them on PATH before starting the backend stack.+ // bin/ β uv + uvx (downloaded by `npm run download-uv`)+ // node/ β official Node.js distribution; provides `node` plus the+ // bundled `npm` / `npx` that stdio MCP servers (Slack, GitHub,+ // Figma, etc.) spawn via `npx -y <package>` (downloaded by+ // `npm run download-node`)+ // `from` is relative to the project root (not directories.app).+ // build:desktop calls both download scripts before invoking electron-builder.+ extraResources: [+ { from: "resources/bin/", to: "bin/", filter: ["**/*"] },+ { from: "resources/node/", to: "node/", filter: ["**/*"] },+ ],++ // ββ macOS ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ+ //+ // Default to the native CPU arch so day-to-day `npm run build:desktop`+ // is fast (one Electron binary, one packaging pass).+ //+ // For a distributable universal build set ELECTRON_ARCH=universal:+ // ELECTRON_ARCH=universal npm run build:desktop+ //+ // Or use the dedicated script:+ // npm run build:desktop:universal+ //+ mac: {+ category: "public.app-category.developer-tools",+ target: [+ {+ target: "dmg",+ arch: [+ process.env.ELECTRON_ARCH ??+ (process.arch === "arm64" ? "arm64" : "x64"),+ ],+ },+ ],+ // Icon auto-discovered from directories.buildResources/icon.png+ // (electron-builder generates icon.icns from the 1024Γ1024 PNG).+ },++ dmg: {+ title: "Agent Canvas",+ contents: [+ { x: 130, y: 220 },+ { x: 410, y: 220, type: "link", path: "/Applications" },+ ],+ window: { width: 540, height: 380 },+ },++ // ββ Windows ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ+ win: {+ target: [{ target: "nsis", arch: ["x64"] }],+ // Icon auto-discovered from directories.buildResources/icon.png+ // (electron-builder generates icon.ico from the 1024Γ1024 PNG).+ },++ nsis: {+ oneClick: false,+ perMachine: false,+ allowToChangeInstallationDirectory: true,+ createDesktopShortcut: true,+ createStartMenuShortcut: true,+ },++ // ββ Linux ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ+ linux: {+ target: [+ { target: "AppImage", arch: ["x64"] },+ { target: "deb", arch: ["x64"] },+ ],+ category: "Development",+ // Icon auto-discovered from directories.buildResources/icon.png.+ },+};++export default config;diff --git a/electron/build-resources/icon.png b/electron/build-resources/icon.pngnew file mode 100644index 0000000000..366c63c9dcBinary files /dev/null and b/electron/build-resources/icon.png differdiff --git a/electron/loading.html b/electron/loading.htmlnew file mode 100644index 0000000000..d500dcd6cc--- /dev/null+++ b/electron/loading.html@@ -0,0 +1,131 @@+<!DOCTYPE html>+<html lang="en">+<head>+ <meta charset="UTF-8" />+ <meta name="viewport" content="width=device-width, initial-scale=1.0" />+ <title>Agent Canvas</title>+ <style>+ *, *::before, *::after { box-sizing: border-box; margin: 0; padding: 0; }++ html, body {+ width: 100%; height: 100%;+ background: #0d0d1a;+ font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto,+ "Helvetica Neue", sans-serif;+ color: #e2e8f0;+ user-select: none;+ -webkit-app-region: drag;+ overflow: hidden;+ }++ .container {+ display: flex;+ flex-direction: column;+ align-items: center;+ justify-content: center;+ height: 100vh;+ gap: 0;+ }++ .logo {+ width: 72px;+ height: 72px;+ margin-bottom: 20px;+ border-radius: 16px;+ background: linear-gradient(135deg, #6366f1 0%, #8b5cf6 50%, #a78bfa 100%);+ display: flex;+ align-items: center;+ justify-content: center;+ font-size: 36px;+ box-shadow: 0 8px 32px rgba(99, 102, 241, 0.4);+ }++ h1 {+ font-size: 22px;+ font-weight: 600;+ letter-spacing: -0.3px;+ margin-bottom: 8px;+ color: #f1f5f9;+ }++ .tagline {+ font-size: 13px;+ color: #64748b;+ margin-bottom: 36px;+ }++ /* Spinner */+ .spinner {+ width: 28px;+ height: 28px;+ border: 2.5px solid #1e293b;+ border-top-color: #6366f1;+ border-radius: 50%;+ animation: spin 0.8s linear infinite;+ margin-bottom: 14px;+ }+ @keyframes spin {+ to { transform: rotate(360deg); }+ }++ .status {+ font-size: 12px;+ color: #475569;+ letter-spacing: 0.3px;+ /* Long lines (e.g. uvx "Installing openhands-agent-server==1.24.0β¦")+ must not push the window or wrap awkwardly. */+ max-width: 360px;+ text-align: center;+ white-space: nowrap;+ overflow: hidden;+ text-overflow: ellipsis;+ }++ .hint {+ margin-top: 14px;+ font-size: 11px;+ color: #334155;+ letter-spacing: 0.2px;+ max-width: 340px;+ text-align: center;+ line-height: 1.5;+ }++ /* Progress dots animation for status text */+ .dots::after {+ content: "";+ animation: dots 1.5s steps(3, end) infinite;+ }+ @keyframes dots {+ 0% { content: ""; }+ 33% { content: "."; }+ 66% { content: ".."; }+ 100% { content: "..."; }+ }+ </style>+</head>+<body>+ <div class="container">+ <div class="logo">π¨</div>+ <h1>Agent Canvas</h1>+ <p class="tagline">AI coding agent interface</p>+ <div class="spinner"></div>+ <p id="status" class="status">Starting services<span class="dots"></span></p>+ <p class="hint">+ First launch downloads Python + the OpenHands agent server.<br />+ This can take a few minutes on a fresh machine.+ </p>+ </div>+ <script>+ // Called from the Electron main process via webContents.executeJavaScript+ // (see electron/main.mjs::setLoadingStatus). Replaces the entire status+ // line, so the animated dots only appear when no concrete status is set.+ window.__setLoadingStatus = function (line) {+ var el = document.getElementById("status");+ if (!el) return;+ var text = String(line == null ? "" : line);+ el.textContent = text || "";+ };+ </script>+</body>+</html>diff --git a/electron/main.mjs b/electron/main.mjsnew file mode 100644index 0000000000..ba62165eba--- /dev/null+++ b/electron/main.mjs@@ -0,0 +1,550 @@+/**+ * Electron Main Process β Agent Canvas Desktop+ *+ * Starts the full Agent Canvas stack (agent-server + automation via uvx,+ * static frontend, ingress proxy), then opens a native BrowserWindow once+ * the ingress is ready. Shows a loading screen while backends start.+ *+ * Path layout (electron-builder uses directories.app: 'electron'):+ *+ * Packaged (macOS example):+ * Contents/Resources/app/ β __dirname (main.mjs lives here)+ * main.mjs+ * loading.html+ * scripts/ β copied from repo scripts/+ * config/ β copied from repo config/+ * build/ β static frontend+ * Contents/Resources/bin/ β process.resourcesPath/bin+ * uv uvx β bundled via extraResources+ *+ * Dev (npm run desktop β electron electron/main.mjs):+ * electron/main.mjs β __dirname = <repo>/electron/+ * scripts/ config/ build/ β one level up: <repo>/+ * system uvx from PATH+ *+ * When packaged, scripts/config/build are siblings of main.mjs so+ * projectRoot === __dirname. In dev they are one level up.+ */++import {+ app,+ BrowserWindow,+ dialog,+ nativeImage,+ nativeTheme,+ shell,+} from "electron";+import { chmodSync, existsSync } from "node:fs";+import { dirname, join } from "node:path";+import { fileURLToPath, pathToFileURL } from "node:url";+import { spawnSync } from "node:child_process";++const __filename = fileURLToPath(import.meta.url);+const __dirname = dirname(__filename);++// ββ Path resolution βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ+// Packaged (directories.app: 'electron'): scripts/config/build are SIBLINGS of+// main.mjs inside Resources/app/, so projectRoot === __dirname.+// Dev (electron electron/main.mjs): those directories are one level UP in the+// repo root, so projectRoot === join(__dirname, '..').++const projectRoot = app.isPackaged ? __dirname : join(__dirname, "..");+const buildDir = join(projectRoot, "build");+const scriptsDir = join(projectRoot, "scripts");++// 1024Γ1024 OpenHands raised-hands app icon. Used as the BrowserWindow.icon+// option for the Linux taskbar and the Windows title bar / taskbar. On macOS+// the dock icon comes from the .app bundle's icon.icns (generated by+// electron-builder from this same PNG), so this path is unused there.+// In dev mode (`npm run desktop`), __dirname is <repo>/electron and the file+// lives next to main.mjs. In a packaged build, electron-builder copies+// build-resources/icon.png into Resources/app/ via the `files:` array.+const appIconPath = join(__dirname, "build-resources", "icon.png");++// ββ Bundled uv ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Inject the bundled uv binary into PATH so that uvx calls inside+ * dev-with-automation.mjs resolve to our bundled binary.+ * No-op in dev mode (falls back to system uv).+ */+function injectBundledUv() {+ if (!app.isPackaged) return;++ const isWin = process.platform === "win32";+ const uvName = isWin ? "uv.exe" : "uv";+ const uvxName = isWin ? "uvx.exe" : "uvx";+ const binDir = join(process.resourcesPath, "bin");+ const uvPath = join(binDir, uvName);++ // We only probe for `uv` here β `uv` and `uvx` ship together in the+ // bundle (`download-uv.mjs` writes both), so if `uv` is present we+ // assume `uvx` is too. `uvxAvailable()` is called separately by+ // start-up code to confirm the resolved binary actually runs.+ if (!existsSync(uvPath)) {+ console.warn("[desktop] Bundled uv not found at", uvPath);+ return;+ }++ // electron-builder copies files without preserving the +x bit on Unix.+ if (!isWin) {+ try {+ chmodSync(uvPath, 0o755);+ const uvxPath = join(binDir, uvxName);+ if (existsSync(uvxPath)) chmodSync(uvxPath, 0o755);+ } catch {}+ }++ const sep = isWin ? ";" : ":";+ process.env.PATH = `${binDir}${sep}${process.env.PATH ?? ""}`;+ console.log("[desktop] Injected bundled uv from", binDir);+}++/**+ * Verify uvx is reachable (either bundled or system).+ * Returns true/false β callers show a dialog on false.+ */+function uvxAvailable() {+ const cmd = process.platform === "win32" ? "uvx.exe" : "uvx";+ const r = spawnSync(cmd, ["--version"], { stdio: "pipe" });+ return r.status === 0;+}++/**+ * Inject the bundled Node.js distribution into PATH so subsequent spawns+ * can find `node`, `npm`, and `npx`.+ *+ * When the app runs as a packaged .app on macOS, the system PATH is minimal+ * (/usr/bin:/bin only) β Homebrew, nvm, asdf etc. installs of Node are+ * invisible. Two breakages flow from that:+ *+ * 1. The dev-with-automation.mjs stack spawns `node scripts/ingress.mjs`+ * and `node scripts/static-server.mjs`; if `node` is not found those+ * processes fail silently and port 8000 never responds.+ * 2. Most stdio MCP marketplace entries (Slack, GitHub, Figma, etc.)+ * use `command: "npx"`. When the agent-server tries to spawn one the+ * missing `npx` makes the spawn fail with ENOENT; the SDK reports it+ * as an `error_kind: "connection"` MCP test failure, surfaced in the+ * install modal as "Could not reach the server".+ *+ * We tried bridging via Electron-as-Node (ELECTRON_RUN_AS_NODE=1) wrappers+ * first. That fixed the ENOENT but introduced a new failure: stdio MCP+ * servers spawned through the wrapper exited with "McpError: Connection+ * closed" before the JSON-RPC handshake completed. Electron-as-Node is+ * fine for our networking helper scripts but its stdin/stdout semantics+ * differ enough from a vanilla `node` binary that stdio JSON-RPC servers+ * are not reliable under it. The robust fix is to ship a real Node.js+ * runtime as an extraResource (see scripts/download-node.mjs and the+ * `resources/node/` entry in electron-builder.config.mjs) and just put+ * its bin dir on PATH.+ *+ * No-op in dev mode (`npm run desktop`): the user's terminal PATH already+ * has Node tooling and `app.isPackaged` is false. If the bundled dir is+ * somehow missing (e.g. the download step was skipped during packaging),+ * we log a loud warning and leave PATH untouched so the failure mode is+ * obvious in the console rather than confusing downstream.+ */+function injectBundledNode() {+ if (!app.isPackaged) return;++ const isWin = process.platform === "win32";+ const nodeRoot = join(process.resourcesPath, "node");+ // POSIX Node distributions put binaries in bin/; Windows zips put node.exe+ // and the npm.cmd / npx.cmd wrappers at the distribution root.+ const binDir = isWin ? nodeRoot : join(nodeRoot, "bin");+ const nodeExe = isWin ? join(nodeRoot, "node.exe") : join(binDir, "node");++ if (!existsSync(nodeExe)) {+ console.warn(+ `[desktop] Bundled Node.js not found at ${nodeExe} β backend ` ++ "scripts and stdio MCP servers will fail. Run `npm run download-node` " ++ "and rebuild.",+ );+ return;+ }++ // electron-builder doesn't always preserve the +x bit on POSIX. node, npm,+ // and npx need to be executable for shell PATH lookup to consider them.+ if (!isWin) {+ const required = ["node", "npm", "npx"];+ for (const name of required) {+ const p = join(binDir, name);+ try {+ if (existsSync(p)) chmodSync(p, 0o755);+ } catch {+ // best-effort: a stale read-only mount or test fixture is fine to skip+ }+ }+ }++ const sep = isWin ? ";" : ":";+ process.env.PATH = `${binDir}${sep}${process.env.PATH ?? ""}`;+ console.log("[desktop] Injected bundled Node from", binDir);+}++// ββ Readiness polling βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Wait until `url` responds at all (status < 500). Used to confirm the+ * ingress proxy is bound β not a guarantee that the agent-server behind it+ * is ready. Use {@link waitForAgentServer} for that.+ */+async function waitForUrl(url, timeoutMs = 120_000, intervalMs = 600) {+ const deadline = Date.now() + timeoutMs;+ while (Date.now() < deadline) {+ try {+ const res = await fetch(url, { signal: AbortSignal.timeout(2000) });+ if (res.status < 500) return;+ } catch {}+ await new Promise((r) => setTimeout(r, intervalMs));+ }+ throw new Error(+ `Timed out waiting for ${url} to become ready (${timeoutMs / 1000}s).`,+ );+}++/**+ * Wait until `url` returns HTTP 200 β meaning the agent-server itself is+ * serving requests, not just that the ingress proxy is up.+ *+ * On first launch, `uvx` has to download a Python toolchain and install+ * `openhands-agent-server` and its workspace deps from PyPI, which can+ * easily take a few minutes on a slow network. We poll the route end-to-end+ * (through ingress on port 8000, so a missing or restarted ingress is also+ * caught) instead of just probing the static-server fallback that+ * `waitForUrl` would accept.+ */+async function waitForAgentServer(+ url = "http://localhost:8000/server_info",+ timeoutMs = 10 * 60_000,+ intervalMs = 1_000,+) {+ const deadline = Date.now() + timeoutMs;+ while (Date.now() < deadline) {+ try {+ const res = await fetch(url, { signal: AbortSignal.timeout(2000) });+ // Only 200 is success here. 502 from ingress means the upstream agent+ // server isn't bound yet; 401 means auth is required and the bundled+ // key didn't reach us β we still treat that as "the agent server is+ // up", because the proxy got a real HTTP response from it.+ if (res.status === 200 || res.status === 401) return;+ } catch {+ // Transient network / DNS / timeout β keep polling until the deadline.+ }+ await new Promise((r) => setTimeout(r, intervalMs));+ }+ throw new Error(+ `Agent server at ${url} never came up (${Math.round(timeoutMs / 1000)}s). ` ++ "Check the terminal log for errors from uvx / the agent-server process.",+ );+}++// ββ Windows βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++let loadingWin = null;+let mainWin = null;++function createLoadingWindow() {+ loadingWin = new BrowserWindow({+ width: 460,+ // Tall enough to fit the streaming status line + the "first launch can+ // take a few minutes" hint without scrollbars.+ height: 360,+ resizable: false,+ frame: false,+ center: true,+ show: false,+ backgroundColor: "#0d0d1a",+ icon: appIconPath,+ webPreferences: {+ nodeIntegration: false,+ contextIsolation: true,+ },+ });++ loadingWin.loadFile(join(__dirname, "loading.html"));+ loadingWin.once("ready-to-show", () => loadingWin?.show());+}++function createMainWindow() {+ mainWin = new BrowserWindow({+ width: 1440,+ height: 900,+ minWidth: 800,+ minHeight: 600,+ show: false,+ titleBarStyle: process.platform === "darwin" ? "hiddenInset" : "default",+ icon: appIconPath,+ webPreferences: {+ nodeIntegration: false,+ contextIsolation: true,+ },+ });++ mainWin.loadURL("http://localhost:8000");++ mainWin.once("ready-to-show", () => {+ loadingWin?.destroy();+ loadingWin = null;+ mainWin?.show();+ mainWin?.maximize();+ });++ // Route window.open() calls appropriately.+ mainWin.webContents.setWindowOpenHandler(({ url }) => {+ // The "Login with OpenHands Cloud" device-flow opens about:blank immediately+ // on the user's click (to beat popup blockers), then navigates the popup to+ // the OAuth verification URL once it has one. We must allow about:blank+ // through so window.open() returns a non-null WindowProxy; the did-create-window+ // handler below redirects the popup to the system browser when it navigates.+ if (url === "about:blank") {+ return {+ action: "allow",+ overrideBrowserWindowOptions: { width: 800, height: 700 },+ };+ }+ // All other external URLs open directly in the system browser.+ if (+ !url.startsWith("http://localhost") &&+ !url.startsWith("http://127.0.0.1")+ ) {+ shell.openExternal(url);+ return { action: "deny" };+ }+ return { action: "allow" };+ });++ // When the renderer opens a popup (the about:blank above), watch for its+ // first navigation away from about:blank. That navigation will be to the+ // OAuth verification URL β open it in the system browser and close the+ // now-unneeded Electron popup.+ mainWin.webContents.on("did-create-window", (popupWin) => {+ popupWin.webContents.on("will-navigate", (_event, url) => {+ if (+ url !== "about:blank" &&+ !url.startsWith("http://localhost") &&+ !url.startsWith("http://127.0.0.1")+ ) {+ _event.preventDefault();+ shell.openExternal(url);+ popupWin.close();+ }+ });+ });++ mainWin.on("closed", () => {+ mainWin = null;+ });+}++// ββ Backend stack βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Update the status line on the loading window, if it's still alive.+ *+ * The loading screen exposes a global `window.__setLoadingStatus(line)`+ * function (see loading.html) that swaps the status text. We call it via+ * `executeJavaScript` so no preload script / IPC plumbing is needed.+ *+ * Best-effort: any failure (window destroyed, JS not loaded yet, etc.) is+ * swallowed β this is purely a UX nicety and must never crash the launcher.+ */+function setLoadingStatus(line) {+ if (!loadingWin || loadingWin.isDestroyed()) return;+ // Limit to a single line, max ~120 chars, to keep the splash readable.+ const oneLine = String(line ?? "")+ .replace(/\s+/g, " ")+ .trim()+ .slice(0, 120);+ if (!oneLine) return;+ const safe = JSON.stringify(oneLine);+ loadingWin.webContents+ .executeJavaScript(+ `window.__setLoadingStatus && window.__setLoadingStatus(${safe});`,+ true,+ )+ .catch(() => {});+}++/**+ * Last few `level: "error"` service log lines (spawn failures, non-zero+ * exits). Appended to the startup-failure dialog: a packaged app launched+ * from Finder has stdout/stderr wired to /dev/null, so without this a+ * crashed ingress/static-server surfaces only as an opaque "timed out+ * waiting for http://localhost:8000" message.+ */+const recentServiceErrors = [];++/**+ * Forward dev-stack service log lines to (a) the loading screen and (b) the+ * terminal log. The terminal already receives them via `logService`; we add+ * a tee here so the user can see what's happening on first launch when uvx+ * is downloading Python + agent-server.+ */+function handleServiceLog(name, line, level) {+ // Skip empty / noisy progress chatter that overwrites itself rapidly.+ // We're mainly interested in agent-server (= uvx output during install).+ if (!line) return;+ if (name === "agent-server" || name === "automation") {+ setLoadingStatus(`${name}: ${line}`);+ }+ // Mirror anything to a `[desktop]` log line in addition to the colored+ // dev-stack output so the desktop log file is grep-friendly.+ if (level === "error") {+ console.error(`[desktop] [${name}] ${line}`);+ // Errors from ANY service (including ingress/static, which the splash+ // filter above skips) are worth showing β a dead ingress is exactly the+ // case where the user would otherwise stare at a silent 120 s timeout.+ setLoadingStatus(`${name}: ${line}`);+ recentServiceErrors.push(`${name}: ${line}`);+ if (recentServiceErrors.length > 5) recentServiceErrors.shift();+ }+}++async function startStack() {+ const entryUrl = pathToFileURL(+ join(scriptsDir, "dev-with-automation.mjs"),+ ).href;+ const { main } = await import(entryUrl);++ // main() starts agent-server + automation backend + static server + ingress.+ // skipNpmCheck: npm is not needed at runtime in static mode.+ // agentServerReadyTimeoutMs: dev defaults to 60 s (warm uvx cache); a+ // packaged binary on a fresh machine can spend several minutes inside+ // uvx the first time, downloading Python + installing openhands-+ // agent-server from PyPI. 10 minutes is generous but bounded.+ // onServiceLog: stream uvx/agent-server output to the loading window so+ // the user sees progress instead of an indefinite spinner.+ const result = await main({+ bannerTitle: "Agent Canvas",+ staticMode: true,+ staticDir: buildDir,+ mode: "agent-canvas",+ isPublic: false,+ skipNpmCheck: true,+ agentServerReadyTimeoutMs: 10 * 60_000,+ onServiceLog: handleServiceLog,+ });++ // main() returns { config, agentServerReady } β treat a timeout as a fatal+ // startup error so the splash shows a clear dialog instead of dropping the+ // user into a half-booted UI that will only emit "Request timeout" popups.+ if (result?.agentServerReady === false) {+ throw new Error(+ "The agent server did not finish starting in time. " ++ "On first launch this can take several minutes while uvx downloads " ++ "Python and the OpenHands agent-server from PyPI. " ++ "Check your internet connection and try again.",+ );+ }+}++// ββ App lifecycle βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++app.whenReady().then(async () => {+ nativeTheme.themeSource = "dark";++ // Set the dock icon explicitly on macOS so `npm run desktop` shows the+ // OpenHands logo instead of the default Electron logo. In a packaged+ // build the .app bundle's icon.icns already provides this, but+ // app.dock.setIcon() is a cheap idempotent override that also fixes+ // the dev workflow.+ if (process.platform === "darwin" && app.dock && existsSync(appIconPath)) {+ app.dock.setIcon(nativeImage.createFromPath(appIconPath));+ }++ injectBundledUv();+ injectBundledNode();++ if (!uvxAvailable()) {+ dialog.showErrorBox(+ "Missing prerequisite: uv",+ app.isPackaged+ ? "The bundled uv binary could not be found. Please reinstall Agent Canvas."+ : "uv (uvx) is not installed.\n\nInstall it from https://docs.astral.sh/uv/ then restart.",+ );+ app.quit();+ return;+ }++ createLoadingWindow();++ try {+ setLoadingStatus("Starting backend servicesβ¦");+ await startStack();++ // Stage 1: ingress proxy is bound (anything < 500 on /).+ setLoadingStatus("Waiting for proxyβ¦");+ await waitForUrl("http://localhost:8000");++ // Stage 2: the agent-server behind the proxy is actually serving+ // requests. `startStack()` already waited for this internally, but we+ // re-probe end-to-end here so that if the user closes the splash race+ // window between processes binding, we still open the main window with+ // a live backend. Cheap (a single 200 response) when everything is up.+ setLoadingStatus("Connecting to agent serverβ¦");+ await waitForAgentServer("http://localhost:8000/server_info", 60_000);++ setLoadingStatus("Ready.");+ createMainWindow();+ } catch (err) {+ const errorTail = recentServiceErrors.length+ ? `\n\nRecent service errors:\n${recentServiceErrors.join("\n")}`+ : "";+ const msg =+ err.message ++ "\n\nEnsure ports 8000, 18000, and 18001 are free, then try again." ++ errorTail;+ dialog.showErrorBox("Agent Canvas failed to start", msg);+ app.quit();+ }+});++// ββ Graceful shutdown βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ+//+// dev-with-automation.mjs spawns the backend processes with detached:true so+// they form their own OS process groups and survive the parent's death by+// default. We must explicitly kill them when the app quits.+//+// createShutdownHookRegistry (dev-process-utils.mjs) already registered a+// SIGTERM handler that iterates every tracked process, calls signalProcessTree+// on its group, waits for exit, then calls process.exit(0). We just need to+// fire that handler before Electron lets the process die.+//+// Flow:+// user closes window / Cmd+Q+// β window-all-closed β app.quit()+// β before-quit fires (first time) β we preventDefault + send SIGTERM+// β SIGTERM handler kills all children, calls process.exit(0)+// β before-quit fires again (cleanupStarted=true) β we return, Electron exits++let cleanupStarted = false;++app.on("before-quit", (event) => {+ if (cleanupStarted) return; // SIGTERM cleanup already running β allow exit++ cleanupStarted = true;+ event.preventDefault();++ console.log("[desktop] Stopping backend servicesβ¦");+ process.kill(process.pid, "SIGTERM");++ // Safety net: if the SIGTERM handler doesn't finish within 6 s, force-quit.+ const t = setTimeout(() => {+ console.warn("[desktop] Cleanup timed out β forcing exit");+ app.exit(0);+ }, 6000);+ if (t.unref) t.unref();+});++app.on("window-all-closed", () => {+ app.quit();+});++// macOS: clicking the dock icon when no window is open re-launches the app.+app.on("activate", () => {+ if (BrowserWindow.getAllWindows().length === 0) {+ // The backend is already running β just open a new renderer window.+ if (mainWin === null) createMainWindow();+ }+});diff --git a/electron/package.json b/electron/package.jsonnew file mode 100644index 0000000000..09b0c7b07b--- /dev/null+++ b/electron/package.json@@ -0,0 +1,6 @@+{+ "name": "agent-canvas",+ "version": "1.0.0",+ "private": true,+ "main": "main.mjs"+}diff --git a/package-lock.json b/package-lock.jsonindex fb2f352658..7acb429f1d 100644--- a/package-lock.json+++ b/package-lock.json@@ -85,6 +85,8 @@"@vercel/react-router": "1.3.0","@vitest/coverage-v8": "4.1.5","cross-env": "10.1.0",+ "electron": "42.3.2",+ "electron-builder": "26.8.1","eslint": "9.39.4","eslint-config-prettier": "10.1.8","eslint-import-resolver-typescript": "4.4.4",@@ -890,6 +892,290 @@"kuler": "^2.0.0"}},+ "node_modules/@develar/schema-utils": {+ "version": "2.6.5",+ "resolved": "https://registry.npmjs.org/@develar/schema-utils/-/schema-utils-2.6.5.tgz",+ "integrity": "sha512-0cp4PsWQ/9avqTVMCtZ+GirikIA36ikvjtHweU4/j8yLtgObI0+JUPhYFScgwlteveGB1rt3Cm8UhN04XayDig==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "ajv": "^6.12.0",+ "ajv-keywords": "^3.4.1"+ },+ "engines": {+ "node": ">= 8.9.0"+ },+ "funding": {+ "type": "opencollective",+ "url": "https://opencollective.com/webpack"+ }+ },+ "node_modules/@electron/asar": {+ "version": "3.4.1",+ "resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz",+ "integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "commander": "^5.0.0",+ "glob": "^7.1.6",+ "minimatch": "^3.0.4"+ },+ "bin": {+ "asar": "bin/asar.js"+ },+ "engines": {+ "node": ">=10.12.0"+ }+ },+ "node_modules/@electron/asar/node_modules/commander": {+ "version": "5.1.0",+ "resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",+ "integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 6"+ }+ },+ "node_modules/@electron/fuses": {+ "version": "1.8.0",+ "resolved": "https://registry.npmjs.org/@electron/fuses/-/fuses-1.8.0.tgz",+ "integrity": "sha512-zx0EIq78WlY/lBb1uXlziZmDZI4ubcCXIMJ4uGjXzZW0nS19TjSPeXPAjzzTmKQlJUZm0SbmZhPKP7tuQ1SsEw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "chalk": "^4.1.1",+ "fs-extra": "^9.0.1",+ "minimist": "^1.2.5"+ },+ "bin": {+ "electron-fuses": "dist/bin.js"+ }+ },+ "node_modules/@electron/fuses/node_modules/fs-extra": {+ "version": "9.1.0",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "at-least-node": "^1.0.0",+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/@electron/get": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-5.0.0.tgz",+ "integrity": "sha512-pjoBpru1KdEtcExBnuHAP1cAc/5faoedw0hzJkL3o4/IJp7HNF1+fbrdxT3gMYRX2oJfvnA/WXeCTVQpYYxyJA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.1.1",+ "env-paths": "^3.0.0",+ "graceful-fs": "^4.2.11",+ "progress": "^2.0.3",+ "semver": "^7.6.3",+ "sumchecker": "^3.0.1"+ },+ "engines": {+ "node": ">=22.12.0"+ },+ "optionalDependencies": {+ "undici": "^7.24.4"+ }+ },+ "node_modules/@electron/notarize": {+ "version": "2.5.0",+ "resolved": "https://registry.npmjs.org/@electron/notarize/-/notarize-2.5.0.tgz",+ "integrity": "sha512-jNT8nwH1f9X5GEITXaQ8IF/KdskvIkOFfB2CvwumsveVidzpSc+mvhhTMdAGSYF3O+Nq49lJ7y+ssODRXu06+A==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.1.1",+ "fs-extra": "^9.0.1",+ "promise-retry": "^2.0.1"+ },+ "engines": {+ "node": ">= 10.0.0"+ }+ },+ "node_modules/@electron/notarize/node_modules/fs-extra": {+ "version": "9.1.0",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "at-least-node": "^1.0.0",+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/@electron/osx-sign": {+ "version": "1.3.3",+ "resolved": "https://registry.npmjs.org/@electron/osx-sign/-/osx-sign-1.3.3.tgz",+ "integrity": "sha512-KZ8mhXvWv2rIEgMbWZ4y33bDHyUKMXnx4M0sTyPNK/vcB81ImdeY9Ggdqy0SWbMDgmbqyQ+phgejh6V3R2QuSg==",+ "dev": true,+ "license": "BSD-2-Clause",+ "dependencies": {+ "compare-version": "^0.1.2",+ "debug": "^4.3.4",+ "fs-extra": "^10.0.0",+ "isbinaryfile": "^4.0.8",+ "minimist": "^1.2.6",+ "plist": "^3.0.5"+ },+ "bin": {+ "electron-osx-flat": "bin/electron-osx-flat.js",+ "electron-osx-sign": "bin/electron-osx-sign.js"+ },+ "engines": {+ "node": ">=12.0.0"+ }+ },+ "node_modules/@electron/osx-sign/node_modules/isbinaryfile": {+ "version": "4.0.10",+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-4.0.10.tgz",+ "integrity": "sha512-iHrqe5shvBUcFbmZq9zOQHBoeOhZJu6RQGrDpBgenUm/Am+F3JM2MgQj+rK3Z601fzrL5gLZWtAPH2OBaSVcyw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 8.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/gjtorikian/"+ }+ },+ "node_modules/@electron/rebuild": {+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/@electron/rebuild/-/rebuild-4.2.0.tgz",+ "integrity": "sha512-RKL/O+jGoXJMxrx/5771y1n0xTKmFuOYGO3gMmwypBM6rsH0kou0mswwdXA2JrhIkE4xyC7v9vGk0n6NPzgOxQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@malept/cross-spawn-promise": "^2.0.0",+ "debug": "^4.1.1",+ "node-abi": "^4.2.0",+ "node-api-version": "^0.2.1",+ "node-gyp": "^12.2.0",+ "read-binary-file-arch": "^1.0.6"+ },+ "bin": {+ "electron-rebuild": "lib/cli.js"+ },+ "engines": {+ "node": ">=22.12.0"+ }+ },+ "node_modules/@electron/universal": {+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/@electron/universal/-/universal-2.0.3.tgz",+ "integrity": "sha512-Wn9sPYIVFRFl5HmwMJkARCCf7rqK/EurkfQ/rJZ14mHP3iYTjZSIOSVonEAnhWeAXwtw7zOekGRlc6yTtZ0t+g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@electron/asar": "^3.3.1",+ "@malept/cross-spawn-promise": "^2.0.0",+ "debug": "^4.3.1",+ "dir-compare": "^4.2.0",+ "fs-extra": "^11.1.1",+ "minimatch": "^9.0.3",+ "plist": "^3.1.0"+ },+ "engines": {+ "node": ">=16.4"+ }+ },+ "node_modules/@electron/universal/node_modules/brace-expansion": {+ "version": "2.1.2",+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.2.tgz",+ "integrity": "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "balanced-match": "^1.0.0"+ }+ },+ "node_modules/@electron/universal/node_modules/fs-extra": {+ "version": "11.3.6",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.6.tgz",+ "integrity": "sha512-w8ZNZr2mKIc7qeNaQ9AVPT1+iFaI+Avd4xudVOvdDJ8VytREi1Ft5Ih7hd9jjehod8vAM5GMsfQ/TpPf4EyoEA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=14.14"+ }+ },+ "node_modules/@electron/universal/node_modules/minimatch": {+ "version": "9.0.9",+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.9.tgz",+ "integrity": "sha512-OBwBN9AL4dqmETlpS2zasx+vTeWclWzkblfZk7KTA5j3jeOONz/tRCnZomUyvNg83wL5Zv9Ss6HMJXAgL8R2Yg==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "brace-expansion": "^2.0.2"+ },+ "engines": {+ "node": ">=16 || 14 >=14.17"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },+ "node_modules/@electron/windows-sign": {+ "version": "1.2.2",+ "resolved": "https://registry.npmjs.org/@electron/windows-sign/-/windows-sign-1.2.2.tgz",+ "integrity": "sha512-dfZeox66AvdPtb2lD8OsIIQh12Tp0GNCRUDfBHIKGpbmopZto2/A8nSpYYLoedPIHpqkeblZ/k8OV0Gy7PYuyQ==",+ "dev": true,+ "license": "BSD-2-Clause",+ "optional": true,+ "peer": true,+ "dependencies": {+ "cross-dirname": "^0.1.0",+ "debug": "^4.3.4",+ "fs-extra": "^11.1.1",+ "minimist": "^1.2.8",+ "postject": "^1.0.0-alpha.6"+ },+ "bin": {+ "electron-windows-sign": "bin/electron-windows-sign.js"+ },+ "engines": {+ "node": ">=14.14"+ }+ },+ "node_modules/@electron/windows-sign/node_modules/fs-extra": {+ "version": "11.3.6",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-11.3.6.tgz",+ "integrity": "sha512-w8ZNZr2mKIc7qeNaQ9AVPT1+iFaI+Avd4xudVOvdDJ8VytREi1Ft5Ih7hd9jjehod8vAM5GMsfQ/TpPf4EyoEA==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "peer": true,+ "dependencies": {+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=14.14"+ }+ },"node_modules/@emnapi/core": {"version": "1.10.0","resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.10.0.tgz",@@ -3262,6 +3548,19 @@"@swc/helpers": "^0.5.0"}},+ "node_modules/@isaacs/fs-minipass": {+ "version": "4.0.1",+ "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",+ "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "minipass": "^7.0.4"+ },+ "engines": {+ "node": ">=18.0.0"+ }+ },"node_modules/@jridgewell/gen-mapping": {"version": "0.3.13","resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",@@ -3307,6 +3606,61 @@"@jridgewell/sourcemap-codec": "^1.4.14"}},+ "node_modules/@malept/cross-spawn-promise": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/@malept/cross-spawn-promise/-/cross-spawn-promise-2.0.0.tgz",+ "integrity": "sha512-1DpKU0Z5ThltBwjNySMC14g0CkbyhCaz9FkhxqNsZI6uAPJXFS8cMXlBKo26FJ8ZuW6S9GCMcR9IO5k2X5/9Fg==",+ "dev": true,+ "funding": [+ {+ "type": "individual",+ "url": "https://github.com/sponsors/malept"+ },+ {+ "type": "tidelift",+ "url": "https://tidelift.com/subscription/pkg/npm-.malept-cross-spawn-promise?utm_medium=referral&utm_source=npm_fund"+ }+ ],+ "license": "Apache-2.0",+ "dependencies": {+ "cross-spawn": "^7.0.1"+ },+ "engines": {+ "node": ">= 12.13.0"+ }+ },+ "node_modules/@malept/flatpak-bundler": {+ "version": "0.4.0",+ "resolved": "https://registry.npmjs.org/@malept/flatpak-bundler/-/flatpak-bundler-0.4.0.tgz",+ "integrity": "sha512-9QOtNffcOF/c1seMCDnjckb3R9WHcG34tky+FHpNKKCW0wc/scYLwMtO+ptyGUfMW0/b/n4qRiALlaFHc9Oj7Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.1.1",+ "fs-extra": "^9.0.0",+ "lodash": "^4.17.15",+ "tmp-promise": "^3.0.2"+ },+ "engines": {+ "node": ">= 10.0.0"+ }+ },+ "node_modules/@malept/flatpak-bundler/node_modules/fs-extra": {+ "version": "9.1.0",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-9.1.0.tgz",+ "integrity": "sha512-hcg3ZmepS30/7BSFqRvoo3DOMQu7IjqxO5nCDt+zM9XWjb33Wg7ziNT+Qvqbuc3+gWpzO02JubVyk2G4Zvo1OQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "at-least-node": "^1.0.0",+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/@microlink/react-json-view": {"version": "1.31.20","resolved": "https://registry.npmjs.org/@microlink/react-json-view/-/react-json-view-1.31.20.tgz",@@ -6205,6 +6559,19 @@"win32"]},+ "node_modules/@sindresorhus/is": {+ "version": "4.6.0",+ "resolved": "https://registry.npmjs.org/@sindresorhus/is/-/is-4.6.0.tgz",+ "integrity": "sha512-t09vSN3MdfsyCHoFcTRCH/iUtG7OJ0CsjzB8cjAmKc/va/kIgeDI/TxsigdncE/4be734m0cvIYwNaV4i2XqAw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sindresorhus/is?sponsor=1"+ }+ },"node_modules/@so-ric/colorspace": {"version": "1.1.6","resolved": "https://registry.npmjs.org/@so-ric/colorspace/-/colorspace-1.1.6.tgz",@@ -6552,6 +6919,19 @@"tslib": "^2.8.0"}},+ "node_modules/@szmarczak/http-timer": {+ "version": "4.0.6",+ "resolved": "https://registry.npmjs.org/@szmarczak/http-timer/-/http-timer-4.0.6.tgz",+ "integrity": "sha512-4BAffykYOgO+5nzBWYwE3W90sBgLJoUPRWWcL8wlyiM8IB8ipJz3UMJ9KXQd1RKQXpKp8Tutn80HZtWsu2u76w==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "defer-to-connect": "^2.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/@tailwindcss/node": {"version": "4.2.4","resolved": "https://registry.npmjs.org/@tailwindcss/node/-/node-4.2.4.tgz",@@ -7017,6 +7397,19 @@"dev": true,"license": "MIT"},+ "node_modules/@types/cacheable-request": {+ "version": "6.0.3",+ "resolved": "https://registry.npmjs.org/@types/cacheable-request/-/cacheable-request-6.0.3.tgz",+ "integrity": "sha512-IQ3EbTzGxIigb1I3qPZc1rWJnH0BmSKv5QYTalEwweFvyBDLSAe24zP0le/hyi7ecGfZVlIVAg4BZqb8WBwKqw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/http-cache-semantics": "*",+ "@types/keyv": "^3.1.4",+ "@types/node": "*",+ "@types/responselike": "^1.0.0"+ }+ },"node_modules/@types/chai": {"version": "5.2.3","resolved": "https://registry.npmjs.org/@types/chai/-/chai-5.2.3.tgz",@@ -7059,6 +7452,16 @@"@types/estree": "*"}},+ "node_modules/@types/fs-extra": {+ "version": "9.0.13",+ "resolved": "https://registry.npmjs.org/@types/fs-extra/-/fs-extra-9.0.13.tgz",+ "integrity": "sha512-nEnwB++1u5lVDM2UI4c1+5R+FYaKfaAzS4OococimjVm3nQw3TuzH5UNsocrcTBbhnerblyHj4A49qXbIiZdpA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/node": "*"+ }+ },"node_modules/@types/hast": {"version": "3.0.4","resolved": "https://registry.npmjs.org/@types/hast/-/hast-3.0.4.tgz",@@ -7068,6 +7471,13 @@"@types/unist": "*"}},+ "node_modules/@types/http-cache-semantics": {+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/@types/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",+ "integrity": "sha512-L3LgimLHXtGkWikKnsPg0/VFx9OGZaC+eN1u4r+OB1XRqH3meBIAVC2zr1WdMH+RHmnRkqliQAOHNJ/E0j/e0Q==",+ "dev": true,+ "license": "MIT"+ },"node_modules/@types/json-schema": {"version": "7.0.15","resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",@@ -7075,6 +7485,16 @@"dev": true,"license": "MIT"},+ "node_modules/@types/keyv": {+ "version": "3.1.4",+ "resolved": "https://registry.npmjs.org/@types/keyv/-/keyv-3.1.4.tgz",+ "integrity": "sha512-BQ5aZNSCpj7D6K2ksrRCTmKRLEpnPvWDiLPfoGyhZ++8YtiK9d/3DBKPJgry359X/P1PfruyYwvnvwFjuEiEIg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/node": "*"+ }+ },"node_modules/@types/lodash": {"version": "4.17.24","resolved": "https://registry.npmjs.org/@types/lodash/-/lodash-4.17.24.tgz",@@ -7105,6 +7525,18 @@"undici-types": "~7.19.0"}},+ "node_modules/@types/plist": {+ "version": "3.0.5",+ "resolved": "https://registry.npmjs.org/@types/plist/-/plist-3.0.5.tgz",+ "integrity": "sha512-E6OCaRmAe4WDmWNsL/9RMqdkkzDCY1etutkflWk4c+AcjDU07Pcz1fQwTX0TQz+Pxqn9i4L1TU3UFpjnrcDgxA==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "@types/node": "*",+ "xmlbuilder": ">=11.0.1"+ }+ },"node_modules/@types/prismjs": {"version": "1.26.6","resolved": "https://registry.npmjs.org/@types/prismjs/-/prismjs-1.26.6.tgz",@@ -7140,6 +7572,16 @@"@types/react": "*"}},+ "node_modules/@types/responselike": {+ "version": "1.0.3",+ "resolved": "https://registry.npmjs.org/@types/responselike/-/responselike-1.0.3.tgz",+ "integrity": "sha512-H/+L+UkTV33uf49PH5pCAUBVPNj2nDBXTN+qS1dOwyyg24l3CcicicCA7ca+HMvJBZcFgl5r8e+RR6elsb4Lyw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/node": "*"+ }+ },"node_modules/@types/set-cookie-parser": {"version": "2.4.10","resolved": "https://registry.npmjs.org/@types/set-cookie-parser/-/set-cookie-parser-2.4.10.tgz",@@ -7182,10 +7624,29 @@"integrity": "sha512-ko/gIFJRv177XgZsZcBwnqJN5x/Gien8qNOn0D5bQU/zAzVf9Zt3BlcUiLqhV9y4ARk0GbT3tnUiPNgnTXzc/Q==","license": "MIT"},- "node_modules/@typescript-eslint/eslint-plugin": {- "version": "8.59.2",- "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.59.2.tgz",- "integrity": "sha512-j/bwmkBvHUtPNxzuWe5z6BEk3q54YRyGlBXkSsmfoih7zNrBvl5A9A98anlp/7JbyZcWIJ8KXo/3Tq/DjFLtuQ==",+ "node_modules/@types/verror": {+ "version": "1.10.11",+ "resolved": "https://registry.npmjs.org/@types/verror/-/verror-1.10.11.tgz",+ "integrity": "sha512-RlDm9K7+o5stv0Co8i8ZRGxDbrTxhJtgjqjFyVh/tXQyl/rYtTKlnTvZ88oSTeYREWurwx20Js4kTuKCsFkUtg==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },+ "node_modules/@types/yauzl": {+ "version": "2.10.3",+ "resolved": "https://registry.npmjs.org/@types/yauzl/-/yauzl-2.10.3.tgz",+ "integrity": "sha512-oJoftv0LSuaDZE3Le4DbKX+KS9G36NzOeSap90UIK0yMA/NhKJhqlSGtNDORNRaIbQfzjXDrQa0ytJ6mNRGz/Q==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "@types/node": "*"+ }+ },+ "node_modules/@typescript-eslint/eslint-plugin": {+ "version": "8.59.2",+ "resolved": "https://registry.npmjs.org/@typescript-eslint/eslint-plugin/-/eslint-plugin-8.59.2.tgz",+ "integrity": "sha512-j/bwmkBvHUtPNxzuWe5z6BEk3q54YRyGlBXkSsmfoih7zNrBvl5A9A98anlp/7JbyZcWIJ8KXo/3Tq/DjFLtuQ==","dev": true,"license": "MIT","dependencies": {@@ -8225,6 +8686,16 @@"url": "https://opencollective.com/vitest"}},+ "node_modules/@xmldom/xmldom": {+ "version": "0.8.13",+ "resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.13.tgz",+ "integrity": "sha512-KRYzxepc14G/CEpEGc3Yn+JKaAeT63smlDr+vjB8jRfgTBBI9wRj/nkQEO+ucV8p8I9bfKLWp37uHgFrbntPvw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10.0.0"+ }+ },"node_modules/@xterm/addon-fit": {"version": "0.11.0","resolved": "https://registry.npmjs.org/@xterm/addon-fit/-/addon-fit-0.11.0.tgz",@@ -8240,6 +8711,23 @@"addons/*"]},+ "node_modules/7zip-bin": {+ "version": "5.2.0",+ "resolved": "https://registry.npmjs.org/7zip-bin/-/7zip-bin-5.2.0.tgz",+ "integrity": "sha512-ukTPVhqG4jNzMro2qA9HSCSSVJN3aN7tlb+hfqYCt3ER0yWroeA2VR38MNrOHLQ/cVj+DaIMad0kFCtWWowh/A==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/abbrev": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/abbrev/-/abbrev-4.0.0.tgz",+ "integrity": "sha512-a1wflyaL0tHtJSmLSOVybYhy22vRih4eduhhrkcjgrWGnRfrZtovJ2FRjxuTtkkj47O/baf0R86QU5OuYpz8fA==",+ "dev": true,+ "license": "ISC",+ "engines": {+ "node": "^20.17.0 || >=22.9.0"+ }+ },"node_modules/accepts": {"version": "1.3.8","resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",@@ -8285,6 +8773,16 @@"acorn": "^6.0.0 || ^7.0.0 || ^8.0.0"}},+ "node_modules/agent-base": {+ "version": "7.1.4",+ "resolved": "https://registry.npmjs.org/agent-base/-/agent-base-7.1.4.tgz",+ "integrity": "sha512-MnA+YT8fwfJPgBx3m60MNqakm30XOkyIoH1y6huTQvC0PwZG7ki8NacLBcrPbNoo8vEZy7Jpuk7+jMO+CUovTQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 14"+ }+ },"node_modules/ajv": {"version": "6.15.0","resolved": "https://registry.npmjs.org/ajv/-/ajv-6.15.0.tgz",@@ -8302,6 +8800,16 @@"url": "https://github.com/sponsors/epoberezkin"}},+ "node_modules/ajv-keywords": {+ "version": "3.5.2",+ "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-3.5.2.tgz",+ "integrity": "sha512-5p6WTN0DdTGVQk6VjcEju19IgaHudalcfabD7yhDGeA6bcQnmL+CpveLJq/3hvfwd1aof6L386Ougkx6RfyMIQ==",+ "dev": true,+ "license": "MIT",+ "peerDependencies": {+ "ajv": "^6.9.1"+ }+ },"node_modules/ansi-escapes": {"version": "7.3.0","resolved": "https://registry.npmjs.org/ansi-escapes/-/ansi-escapes-7.3.0.tgz",@@ -8344,6 +8852,236 @@"url": "https://github.com/chalk/ansi-styles?sponsor=1"}},+ "node_modules/app-builder-bin": {+ "version": "5.0.0-alpha.12",+ "resolved": "https://registry.npmjs.org/app-builder-bin/-/app-builder-bin-5.0.0-alpha.12.tgz",+ "integrity": "sha512-j87o0j6LqPL3QRr8yid6c+Tt5gC7xNfYo6uQIQkorAC6MpeayVMZrEDzKmJJ/Hlv7EnOQpaRm53k6ktDYZyB6w==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/app-builder-lib": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/app-builder-lib/-/app-builder-lib-26.8.1.tgz",+ "integrity": "sha512-p0Im/Dx5C4tmz8QEE1Yn4MkuPC8PrnlRneMhWJj7BBXQfNTJUshM/bp3lusdEsDbvvfJZpXWnYesgSLvwtM2Zw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@develar/schema-utils": "~2.6.5",+ "@electron/asar": "3.4.1",+ "@electron/fuses": "^1.8.0",+ "@electron/get": "^3.0.0",+ "@electron/notarize": "2.5.0",+ "@electron/osx-sign": "1.3.3",+ "@electron/rebuild": "^4.0.3",+ "@electron/universal": "2.0.3",+ "@malept/flatpak-bundler": "^0.4.0",+ "@types/fs-extra": "9.0.13",+ "async-exit-hook": "^2.0.1",+ "builder-util": "26.8.1",+ "builder-util-runtime": "9.5.1",+ "chromium-pickle-js": "^0.2.0",+ "ci-info": "4.3.1",+ "debug": "^4.3.4",+ "dotenv": "^16.4.5",+ "dotenv-expand": "^11.0.6",+ "ejs": "^3.1.8",+ "electron-publish": "26.8.1",+ "fs-extra": "^10.1.0",+ "hosted-git-info": "^4.1.0",+ "isbinaryfile": "^5.0.0",+ "jiti": "^2.4.2",+ "js-yaml": "^4.1.0",+ "json5": "^2.2.3",+ "lazy-val": "^1.0.5",+ "minimatch": "^10.0.3",+ "plist": "3.1.0",+ "proper-lockfile": "^4.1.2",+ "resedit": "^1.7.0",+ "semver": "~7.7.3",+ "tar": "^7.5.7",+ "temp-file": "^3.4.0",+ "tiny-async-pool": "1.3.0",+ "which": "^5.0.0"+ },+ "engines": {+ "node": ">=14.0.0"+ },+ "peerDependencies": {+ "dmg-builder": "26.8.1",+ "electron-builder-squirrel-windows": "26.8.1"+ }+ },+ "node_modules/app-builder-lib/node_modules/@electron/get": {+ "version": "3.1.0",+ "resolved": "https://registry.npmjs.org/@electron/get/-/get-3.1.0.tgz",+ "integrity": "sha512-F+nKc0xW+kVbBRhFzaMgPy3KwmuNTYX1fx6+FxxoSnNgwYX6LD7AKBTWkU0MQ6IBoe7dz069CNkR673sPAgkCQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.1.1",+ "env-paths": "^2.2.0",+ "fs-extra": "^8.1.0",+ "got": "^11.8.5",+ "progress": "^2.0.3",+ "semver": "^6.2.0",+ "sumchecker": "^3.0.1"+ },+ "engines": {+ "node": ">=14"+ },+ "optionalDependencies": {+ "global-agent": "^3.0.0"+ }+ },+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/fs-extra": {+ "version": "8.1.0",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-8.1.0.tgz",+ "integrity": "sha512-yhlQgA6mnOJUKOsRUFsgJdQCvkKhcz8tlZG5HBQfReYZy46OwLcY+Zia0mtdHsOo9y/hP+CxMN0TU9QxoOtG4g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "graceful-fs": "^4.2.0",+ "jsonfile": "^4.0.0",+ "universalify": "^0.1.0"+ },+ "engines": {+ "node": ">=6 <7 || >=8"+ }+ },+ "node_modules/app-builder-lib/node_modules/@electron/get/node_modules/semver": {+ "version": "6.3.1",+ "resolved": "https://registry.npmjs.org/semver/-/semver-6.3.1.tgz",+ "integrity": "sha512-BR7VvDCVHO+q2xBEWskxS6DJE1qRnb7DxzUrogb71CWoSficBxYsiAGd+Kl0mmq/MprG9yArRkyrQxTO6XjMzA==",+ "dev": true,+ "license": "ISC",+ "bin": {+ "semver": "bin/semver.js"+ }+ },+ "node_modules/app-builder-lib/node_modules/balanced-match": {+ "version": "4.0.4",+ "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",+ "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "18 || 20 || >=22"+ }+ },+ "node_modules/app-builder-lib/node_modules/brace-expansion": {+ "version": "5.0.7",+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.7.tgz",+ "integrity": "sha512-7oFy703dxfY3/NLxC1fh2SUCQ0H9rmAY+5EpDVfXjUTTs+HEwR2nYaqLv+GWcTsumwxPfiz6CzCNkwXwBUwqCA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "balanced-match": "^4.0.2"+ },+ "engines": {+ "node": "18 || 20 || >=22"+ }+ },+ "node_modules/app-builder-lib/node_modules/ci-info": {+ "version": "4.3.1",+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.3.1.tgz",+ "integrity": "sha512-Wdy2Igu8OcBpI2pZePZ5oWjPC38tmDVx5WKUXKwlLYkA0ozo85sLsLvkBbBn/sZaSCMFOGZJ14fvW9t5/d7kdA==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/sibiraj-s"+ }+ ],+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/app-builder-lib/node_modules/env-paths": {+ "version": "2.2.1",+ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",+ "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6"+ }+ },+ "node_modules/app-builder-lib/node_modules/isexe": {+ "version": "3.1.5",+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-3.1.5.tgz",+ "integrity": "sha512-6B3tLtFqtQS4ekarvLVMZ+X+VlvQekbe4taUkf/rhVO3d/h0M2rfARm/pXLcPEsjjMsFgrFgSrhQIxcSVrBz8w==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=18"+ }+ },+ "node_modules/app-builder-lib/node_modules/jsonfile": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",+ "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",+ "dev": true,+ "license": "MIT",+ "optionalDependencies": {+ "graceful-fs": "^4.1.6"+ }+ },+ "node_modules/app-builder-lib/node_modules/minimatch": {+ "version": "10.2.5",+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.5.tgz",+ "integrity": "sha512-MULkVLfKGYDFYejP07QOurDLLQpcjk7Fw+7jXS2R2czRQzR56yHRveU5NDJEOviH+hETZKSkIk5c+T23GjFUMg==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "dependencies": {+ "brace-expansion": "^5.0.5"+ },+ "engines": {+ "node": "18 || 20 || >=22"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },+ "node_modules/app-builder-lib/node_modules/semver": {+ "version": "7.7.4",+ "resolved": "https://registry.npmjs.org/semver/-/semver-7.7.4.tgz",+ "integrity": "sha512-vFKC2IEtQnVhpT78h1Yp8wzwrf8CM+MzKMHGJZfBtzhZNycRFnXsHk6E5TxIkkMsgNS7mdX3AGB7x2QM2di4lA==",+ "dev": true,+ "license": "ISC",+ "bin": {+ "semver": "bin/semver.js"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/app-builder-lib/node_modules/universalify": {+ "version": "0.1.2",+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",+ "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 4.0.0"+ }+ },+ "node_modules/app-builder-lib/node_modules/which": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/which/-/which-5.0.0.tgz",+ "integrity": "sha512-JEdGzHwwkrbWoGOlIHqQ5gtprKGOenpDHpxE9zVR1bWbOtYRyPPHMe9FaP6x61CmNaTThSkb0DAJte5jD+DmzQ==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "isexe": "^3.1.1"+ },+ "bin": {+ "node-which": "bin/which.js"+ },+ "engines": {+ "node": "^18.17.0 || >=20.5.0"+ }+ },"node_modules/arg": {"version": "5.0.2","resolved": "https://registry.npmjs.org/arg/-/arg-5.0.2.tgz",@@ -8524,6 +9262,17 @@"url": "https://github.com/sponsors/ljharb"}},+ "node_modules/assert-plus": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/assert-plus/-/assert-plus-1.0.0.tgz",+ "integrity": "sha512-NfJ4UzBCcQGLDlQq7nHxH+tv3kyZ0hHQqF5BO6J7tNJeP5do1llPr8dZ8zHonfhAu0PHAdMkSo+8o0wxg9lZWw==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "engines": {+ "node": ">=0.8"+ }+ },"node_modules/assertion-error": {"version": "2.0.1","resolved": "https://registry.npmjs.org/assertion-error/-/assertion-error-2.0.1.tgz",@@ -8560,12 +9309,33 @@"dev": true,"license": "MIT"},+ "node_modules/astral-regex": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/astral-regex/-/astral-regex-2.0.0.tgz",+ "integrity": "sha512-Z7tMw1ytTXt5jqMcOP+OQteU1VuNK9Y02uuJtKQ1Sv69jXQKKg5cibLwGJow8yzZP+eAc18EmLGPal0bp36rvQ==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "engines": {+ "node": ">=8"+ }+ },"node_modules/async": {"version": "3.2.6","resolved": "https://registry.npmjs.org/async/-/async-3.2.6.tgz","integrity": "sha512-htCUDlxyyCLMgaM3xXg0C0LW2xqfuQ6p05pCEIsXuyQ+a1koYKTuBMzRNwmybfLgvJDMd0r1LTn4+E0Ti6C2AA==","license": "MIT"},+ "node_modules/async-exit-hook": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/async-exit-hook/-/async-exit-hook-2.0.1.tgz",+ "integrity": "sha512-NW2cX8m1Q7KPA7a5M2ULQeZ2wR5qI5PAbw5L0UOMxdioVk9PMZ0h1TmyZEkPYrCvYjDlFICusOu1dlEKAAeXBw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=0.12.0"+ }+ },"node_modules/async-function": {"version": "1.0.0","resolved": "https://registry.npmjs.org/async-function/-/async-function-1.0.0.tgz",@@ -8582,6 +9352,16 @@"integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==","license": "MIT"},+ "node_modules/at-least-node": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/at-least-node/-/at-least-node-1.0.0.tgz",+ "integrity": "sha512-+q/t7Ekv1EDY2l6Gda6LLiX14rU9TV20Wa3ofeQmwPFZbOMo9DXrLbOjFaaclkXKWidIaopwAObQDqwWtGUjqg==",+ "dev": true,+ "license": "ISC",+ "engines": {+ "node": ">= 4.0.0"+ }+ },"node_modules/available-typed-arrays": {"version": "1.0.7","resolved": "https://registry.npmjs.org/available-typed-arrays/-/available-typed-arrays-1.0.7.tgz",@@ -8659,6 +9439,27 @@"dev": true,"license": "MIT"},+ "node_modules/base64-js": {+ "version": "1.5.1",+ "resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",+ "integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/feross"+ },+ {+ "type": "patreon",+ "url": "https://www.patreon.com/feross"+ },+ {+ "type": "consulting",+ "url": "https://feross.org/support"+ }+ ],+ "license": "MIT"+ },"node_modules/baseline-browser-mapping": {"version": "2.10.33","resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.10.33.tgz",@@ -8739,6 +9540,15 @@"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==","license": "MIT"},+ "node_modules/boolean": {+ "version": "3.2.0",+ "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz",+ "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==",+ "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",+ "dev": true,+ "license": "MIT",+ "optional": true+ },"node_modules/brace-expansion": {"version": "1.1.15","resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.15.tgz",@@ -8797,23 +9607,98 @@"node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"}},+ "node_modules/buffer": {+ "version": "5.7.1",+ "resolved": "https://registry.npmjs.org/buffer/-/buffer-5.7.1.tgz",+ "integrity": "sha512-EHcyIPBQ4BSGlvjB16k5KgAJ27CIsHY/2JBmCRReo48y9rQ3MaUzWX3KVlBa4U7MyX02HdVj0K7C3WaB3ju7FQ==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/feross"+ },+ {+ "type": "patreon",+ "url": "https://www.patreon.com/feross"+ },+ {+ "type": "consulting",+ "url": "https://feross.org/support"+ }+ ],+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "base64-js": "^1.3.1",+ "ieee754": "^1.1.13"+ }+ },+ "node_modules/buffer-crc32": {+ "version": "0.2.13",+ "resolved": "https://registry.npmjs.org/buffer-crc32/-/buffer-crc32-0.2.13.tgz",+ "integrity": "sha512-VO9Ht/+p3SN7SKWqcrgEzjGbRSJYTx+Q1pTQC0wrWqHx0vpJraQ6GtHx8tvcg1rlK1byhU5gccxgOgj7B0TDkQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": "*"+ }+ },"node_modules/buffer-from": {"version": "1.1.2","resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz","integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==","license": "MIT"},- "node_modules/bytes": {- "version": "3.1.2",- "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",- "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",+ "node_modules/builder-util": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/builder-util/-/builder-util-26.8.1.tgz",+ "integrity": "sha512-pm1lTYbGyc90DHgCDO7eo8Rl4EqKLciayNbZqGziqnH9jrlKe8ZANGdityLZU+pJh16dfzjAx2xQq9McuIPEtw==",+ "dev": true,"license": "MIT",- "engines": {- "node": ">= 0.8"+ "dependencies": {+ "@types/debug": "^4.1.6",+ "7zip-bin": "~5.2.0",+ "app-builder-bin": "5.0.0-alpha.12",+ "builder-util-runtime": "9.5.1",+ "chalk": "^4.1.2",+ "cross-spawn": "^7.0.6",+ "debug": "^4.3.4",+ "fs-extra": "^10.1.0",+ "http-proxy-agent": "^7.0.0",+ "https-proxy-agent": "^7.0.0",+ "js-yaml": "^4.1.0",+ "sanitize-filename": "^1.6.3",+ "source-map-support": "^0.5.19",+ "stat-mode": "^1.0.0",+ "temp-file": "^3.4.0",+ "tiny-async-pool": "1.3.0"}},- "node_modules/cac": {- "version": "6.7.14",+ "node_modules/builder-util-runtime": {+ "version": "9.5.1",+ "resolved": "https://registry.npmjs.org/builder-util-runtime/-/builder-util-runtime-9.5.1.tgz",+ "integrity": "sha512-qt41tMfgHTllhResqM5DcnHyDIWNgzHvuY2jDcYP9iaGpkWxTUzV6GQjDeLnlR1/DtdlcsWQbA7sByMpmJFTLQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.3.4",+ "sax": "^1.2.4"+ },+ "engines": {+ "node": ">=12.0.0"+ }+ },+ "node_modules/bytes": {+ "version": "3.1.2",+ "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",+ "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",+ "license": "MIT",+ "engines": {+ "node": ">= 0.8"+ }+ },+ "node_modules/cac": {+ "version": "6.7.14","resolved": "https://registry.npmjs.org/cac/-/cac-6.7.14.tgz","integrity": "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==","dev": true,@@ -8822,6 +9707,35 @@"node": ">=8"}},+ "node_modules/cacheable-lookup": {+ "version": "5.0.4",+ "resolved": "https://registry.npmjs.org/cacheable-lookup/-/cacheable-lookup-5.0.4.tgz",+ "integrity": "sha512-2/kNscPhpcxrOigMZzbiWF7dz8ilhb/nIHU3EyZiXWXpeq/au8qJ8VhdftMkty3n7Gj6HIGalQG8oiBNB3AJgA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10.6.0"+ }+ },+ "node_modules/cacheable-request": {+ "version": "7.0.4",+ "resolved": "https://registry.npmjs.org/cacheable-request/-/cacheable-request-7.0.4.tgz",+ "integrity": "sha512-v+p6ongsrp0yTGbJXjgxPow2+DL93DASP4kXCDKb8/bwRtt9OEF3whggkkDkGNzgcWy2XaF4a8nZglC7uElscg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "clone-response": "^1.0.2",+ "get-stream": "^5.1.0",+ "http-cache-semantics": "^4.0.0",+ "keyv": "^4.0.0",+ "lowercase-keys": "^2.0.0",+ "normalize-url": "^6.0.1",+ "responselike": "^2.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },"node_modules/call-bind": {"version": "1.0.9","resolved": "https://registry.npmjs.org/call-bind/-/call-bind-1.0.9.tgz",@@ -9007,6 +9921,39 @@"url": "https://paulmillr.com/funding/"}},+ "node_modules/chownr": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",+ "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=18"+ }+ },+ "node_modules/chromium-pickle-js": {+ "version": "0.2.0",+ "resolved": "https://registry.npmjs.org/chromium-pickle-js/-/chromium-pickle-js-0.2.0.tgz",+ "integrity": "sha512-1R5Fho+jBq0DDydt+/vHWj5KJNJCKdARKOCwZUen84I5BreWoLqRLANH1U87eJy1tiASPtMnGqJJq0ZsLoRPOw==",+ "dev": true,+ "license": "MIT"+ },+ "node_modules/ci-info": {+ "version": "4.4.0",+ "resolved": "https://registry.npmjs.org/ci-info/-/ci-info-4.4.0.tgz",+ "integrity": "sha512-77PSwercCZU2Fc4sX94eF8k8Pxte6JAwL4/ICZLFjJLqegs7kCuAsqqj/70NQF6TvDpgFjkubQB2FW2ZZddvQg==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/sibiraj-s"+ }+ ],+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },"node_modules/class-variance-authority": {"version": "0.7.1","resolved": "https://registry.npmjs.org/class-variance-authority/-/class-variance-authority-0.7.1.tgz",@@ -9146,6 +10093,19 @@"url": "https://github.com/chalk/wrap-ansi?sponsor=1"}},+ "node_modules/clone-response": {+ "version": "1.0.3",+ "resolved": "https://registry.npmjs.org/clone-response/-/clone-response-1.0.3.tgz",+ "integrity": "sha512-ROoL94jJH2dUVML2Y/5PEDNaSHgeOdSDicUyS7izcF63G6sTc/FTjLub4b8Il9S8S0beOfYt0TaA5qvFK+w0wA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "mimic-response": "^1.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/clsx": {"version": "2.1.1","resolved": "https://registry.npmjs.org/clsx/-/clsx-2.1.1.tgz",@@ -9258,6 +10218,16 @@"node": ">= 12.0.0"}},+ "node_modules/compare-version": {+ "version": "0.1.2",+ "resolved": "https://registry.npmjs.org/compare-version/-/compare-version-0.1.2.tgz",+ "integrity": "sha512-pJDh5/4wrEnXX/VWRZvruAGHkzKdr46z11OlTPN+VrATlWWhSKewNCJ1futCO5C7eJB3nPMFZA1LeYtcFboZ2A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=0.10.0"+ }+ },"node_modules/compressible": {"version": "2.0.18","resolved": "https://registry.npmjs.org/compressible/-/compressible-2.0.18.tgz",@@ -9386,6 +10356,14 @@"url": "https://opencollective.com/core-js"}},+ "node_modules/core-util-is": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/core-util-is/-/core-util-is-1.0.2.tgz",+ "integrity": "sha512-3lqz5YjWTYnW6dlDa5TLaTCcShfar1e40rmcJVwCBJC6mWlFuj0eCHIElmG1g5kyuJ/GD+8Wn4FFCcz4gJPfaQ==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },"node_modules/cosmiconfig": {"version": "8.3.6","resolved": "https://registry.npmjs.org/cosmiconfig/-/cosmiconfig-8.3.6.tgz",@@ -9413,6 +10391,26 @@}}},+ "node_modules/crc": {+ "version": "3.8.0",+ "resolved": "https://registry.npmjs.org/crc/-/crc-3.8.0.tgz",+ "integrity": "sha512-iX3mfgcTMIq3ZKLIsVFAbv7+Mc10kxabAGQb8HvjA1o3T1PIYprbakQ65d3I+2HGHt6nSKkM9PYjgoJO2KcFBQ==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "buffer": "^5.1.0"+ }+ },+ "node_modules/cross-dirname": {+ "version": "0.1.0",+ "resolved": "https://registry.npmjs.org/cross-dirname/-/cross-dirname-0.1.0.tgz",+ "integrity": "sha512-+R08/oI0nl3vfPcqftZRpytksBXDzOUveBq/NBVx0sUp1axwzPQrKinNx5yd5sxPu8j1wIy8AfnVQ+5eFdha6Q==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "peer": true+ },"node_modules/cross-env": {"version": "10.1.0","resolved": "https://registry.npmjs.org/cross-env/-/cross-env-10.1.0.tgz",@@ -9597,6 +10595,35 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/decompress-response": {+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/decompress-response/-/decompress-response-6.0.0.tgz",+ "integrity": "sha512-aW35yZM6Bb/4oJlZncMH2LCoZtJXTRxES17vE3hoRiowU2kWHaJKFkSBDnDR+cm9J+9QhXmREyIfv0pji9ejCQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "mimic-response": "^3.1.0"+ },+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/decompress-response/node_modules/mimic-response": {+ "version": "3.1.0",+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-3.1.0.tgz",+ "integrity": "sha512-z0yWI+4FDrrweS8Zmt4Ej5HdJmky15+L2e6Wgn3+iK5fWzb6T3fhNFq2+MeTRb064c6Wr4N/wv0DzQTjNzHNGQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/dedent": {"version": "1.7.2","resolved": "https://registry.npmjs.org/dedent/-/dedent-1.7.2.tgz",@@ -9628,6 +10655,16 @@"node": ">=0.10.0"}},+ "node_modules/defer-to-connect": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/defer-to-connect/-/defer-to-connect-2.0.1.tgz",+ "integrity": "sha512-4tvttepXG1VaYGrRibk5EwJd1t4udunSOVMdLSAL6mId1ix438oPwPZMALY41FCijukO1L0twNcGsdzS7dHgDg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ }+ },"node_modules/define-data-property": {"version": "1.1.4","resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",@@ -9710,6 +10747,14 @@"node": ">=8"}},+ "node_modules/detect-node": {+ "version": "2.1.0",+ "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",+ "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },"node_modules/devlop": {"version": "1.1.0","resolved": "https://registry.npmjs.org/devlop/-/devlop-1.1.0.tgz",@@ -9723,6 +10768,74 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/dir-compare": {+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/dir-compare/-/dir-compare-4.2.0.tgz",+ "integrity": "sha512-2xMCmOoMrdQIPHdsTawECdNPwlVFB9zGcz3kuhmBO6U3oU+UQjsue0i8ayLKpgBcm+hcXPMVSGUN9d+pvJ6+VQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "minimatch": "^3.0.5",+ "p-limit": "^3.1.0 "+ }+ },+ "node_modules/dmg-builder": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/dmg-builder/-/dmg-builder-26.8.1.tgz",+ "integrity": "sha512-glMJgnTreo8CFINujtAhCgN96QAqApDMZ8Vl1r8f0QT8QprvC1UCltV4CcWj20YoIyLZx6IUskaJZ0NV8fokcg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "app-builder-lib": "26.8.1",+ "builder-util": "26.8.1",+ "fs-extra": "^10.1.0",+ "iconv-lite": "^0.6.2",+ "js-yaml": "^4.1.0"+ },+ "optionalDependencies": {+ "dmg-license": "^1.0.11"+ }+ },+ "node_modules/dmg-builder/node_modules/iconv-lite": {+ "version": "0.6.3",+ "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.6.3.tgz",+ "integrity": "sha512-4fCk79wshMdzMp2rH06qWrJE4iolqLhCUH+OiuIgU++RB0+94NlDL81atO7GX55uUKueo0txHNtvEyI6D7WdMw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "safer-buffer": ">= 2.1.2 < 3.0.0"+ },+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/dmg-license": {+ "version": "1.0.11",+ "resolved": "https://registry.npmjs.org/dmg-license/-/dmg-license-1.0.11.tgz",+ "integrity": "sha512-ZdzmqwKmECOWJpqefloC5OJy1+WZBBse5+MR88z9g9Zn4VY+WYUkAyojmhzJckH5YbbZGcYIuGAkY5/Ys5OM2Q==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "dependencies": {+ "@types/plist": "^3.0.1",+ "@types/verror": "^1.10.3",+ "ajv": "^6.10.0",+ "crc": "^3.8.0",+ "iconv-corefoundation": "^1.1.7",+ "plist": "^3.0.4",+ "smart-buffer": "^4.0.2",+ "verror": "^1.10.0"+ },+ "bin": {+ "dmg-license": "bin/dmg-license.js"+ },+ "engines": {+ "node": ">=8"+ }+ },"node_modules/doctrine": {"version": "2.1.0","resolved": "https://registry.npmjs.org/doctrine/-/doctrine-2.1.0.tgz",@@ -9773,6 +10886,35 @@"tslib": "^2.0.3"}},+ "node_modules/dotenv": {+ "version": "16.6.1",+ "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.6.1.tgz",+ "integrity": "sha512-uBq4egWHTcTt33a72vpSG0z3HnPuIl6NqYcTrKEg2azoEyl2hpW0zqlxysq2pK9HlDIHyHyakeYaYnSAwd8bow==",+ "dev": true,+ "license": "BSD-2-Clause",+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://dotenvx.com"+ }+ },+ "node_modules/dotenv-expand": {+ "version": "11.0.7",+ "resolved": "https://registry.npmjs.org/dotenv-expand/-/dotenv-expand-11.0.7.tgz",+ "integrity": "sha512-zIHwmZPRshsCdpMDyVsqGmgyP0yT8GAgXUnkdAoJisxvf33k7yO6OuoKmcTGuXPWSsm8Oh88nZicRLA9Y0rUeA==",+ "dev": true,+ "license": "BSD-2-Clause",+ "dependencies": {+ "dotenv": "^16.4.5"+ },+ "engines": {+ "node": ">=12"+ },+ "funding": {+ "url": "https://dotenvx.com"+ }+ },"node_modules/downshift": {"version": "9.3.2","resolved": "https://registry.npmjs.org/downshift/-/downshift-9.3.2.tgz",@@ -9809,6 +10951,111 @@"integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==","license": "MIT"},+ "node_modules/ejs": {+ "version": "3.1.10",+ "resolved": "https://registry.npmjs.org/ejs/-/ejs-3.1.10.tgz",+ "integrity": "sha512-UeJmFfOrAQS8OJWPZ4qtgHyWExa088/MtK5UEyoJGFH67cDEXkZSviOiKRCZ4Xij0zxI3JECgYs3oKx+AizQBA==",+ "dev": true,+ "license": "Apache-2.0",+ "dependencies": {+ "jake": "^10.8.5"+ },+ "bin": {+ "ejs": "bin/cli.js"+ },+ "engines": {+ "node": ">=0.10.0"+ }+ },+ "node_modules/electron": {+ "version": "42.3.2",+ "resolved": "https://registry.npmjs.org/electron/-/electron-42.3.2.tgz",+ "integrity": "sha512-R8qL6TMQ+u5r/l1mL6zWqqK3eQo6Bqi4ScmysgODcy+SNR76HQhvbZUEL/9GqNuF0fNFJxphz/bh/TC4jW8NbA==",+ "deprecated": "This version of Electron has a critical bug in Buffer handling, please upgrade to 42.3.3",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@electron/get": "^5.0.0",+ "@types/node": "^24.9.0",+ "extract-zip": "^2.0.1"+ },+ "bin": {+ "electron": "cli.js",+ "install-electron": "install.js"+ },+ "engines": {+ "node": ">= 22.12.0"+ }+ },+ "node_modules/electron-builder": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/electron-builder/-/electron-builder-26.8.1.tgz",+ "integrity": "sha512-uWhx1r74NGpCagG0ULs/P9Nqv2nsoo+7eo4fLUOB8L8MdWltq9odW/uuLXMFCDGnPafknYLZgjNX0ZIFRzOQAw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "app-builder-lib": "26.8.1",+ "builder-util": "26.8.1",+ "builder-util-runtime": "9.5.1",+ "chalk": "^4.1.2",+ "ci-info": "^4.2.0",+ "dmg-builder": "26.8.1",+ "fs-extra": "^10.1.0",+ "lazy-val": "^1.0.5",+ "simple-update-notifier": "2.0.0",+ "yargs": "^17.6.2"+ },+ "bin": {+ "electron-builder": "cli.js",+ "install-app-deps": "install-app-deps.js"+ },+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/electron-builder-squirrel-windows": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/electron-builder-squirrel-windows/-/electron-builder-squirrel-windows-26.8.1.tgz",+ "integrity": "sha512-o288fIdgPLHA76eDrFADHPoo7VyGkDCYbLV1GzndaMSAVBoZrGvM9m2IehdcVMzdAZJ2eV9bgyissQXHv5tGzA==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "app-builder-lib": "26.8.1",+ "builder-util": "26.8.1",+ "electron-winstaller": "5.4.0"+ }+ },+ "node_modules/electron-publish": {+ "version": "26.8.1",+ "resolved": "https://registry.npmjs.org/electron-publish/-/electron-publish-26.8.1.tgz",+ "integrity": "sha512-q+jrSTIh/Cv4eGZa7oVR+grEJo/FoLMYBAnSL5GCtqwUpr1T+VgKB/dn1pnzxIxqD8S/jP1yilT9VrwCqINR4w==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@types/fs-extra": "^9.0.11",+ "builder-util": "26.8.1",+ "builder-util-runtime": "9.5.1",+ "chalk": "^4.1.2",+ "form-data": "^4.0.5",+ "fs-extra": "^10.1.0",+ "lazy-val": "^1.0.5",+ "mime": "^2.5.2"+ }+ },+ "node_modules/electron-publish/node_modules/mime": {+ "version": "2.6.0",+ "resolved": "https://registry.npmjs.org/mime/-/mime-2.6.0.tgz",+ "integrity": "sha512-USPkMeET31rOMiarsBNIHZKLGgvKc/LrjofAnBlOttf5ajRvqiRA8QsenbcooctK6d6Ts6aqZXBA+XbkKthiQg==",+ "dev": true,+ "license": "MIT",+ "bin": {+ "mime": "cli.js"+ },+ "engines": {+ "node": ">=4.0.0"+ }+ },"node_modules/electron-to-chromium": {"version": "1.5.368","resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.368.tgz",@@ -9816,6 +11063,83 @@"dev": true,"license": "ISC"},+ "node_modules/electron-winstaller": {+ "version": "5.4.0",+ "resolved": "https://registry.npmjs.org/electron-winstaller/-/electron-winstaller-5.4.0.tgz",+ "integrity": "sha512-bO3y10YikuUwUuDUQRM4KfwNkKhnpVO7IPdbsrejwN9/AABJzzTQ4GeHwyzNSrVO+tEH3/Np255a3sVZpZDjvg==",+ "dev": true,+ "hasInstallScript": true,+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "@electron/asar": "^3.2.1",+ "debug": "^4.1.1",+ "fs-extra": "^7.0.1",+ "lodash": "^4.17.21",+ "temp": "^0.9.0"+ },+ "engines": {+ "node": ">=8.0.0"+ },+ "optionalDependencies": {+ "@electron/windows-sign": "^1.1.2"+ }+ },+ "node_modules/electron-winstaller/node_modules/fs-extra": {+ "version": "7.0.1",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-7.0.1.tgz",+ "integrity": "sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "graceful-fs": "^4.1.2",+ "jsonfile": "^4.0.0",+ "universalify": "^0.1.0"+ },+ "engines": {+ "node": ">=6 <7 || >=8"+ }+ },+ "node_modules/electron-winstaller/node_modules/jsonfile": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-4.0.0.tgz",+ "integrity": "sha512-m6F1R3z8jjlf2imQHS2Qez5sjKWQzbuuhuJ/FKYFRZvPE3PuHcSMVZzfsLhGVOkfd20obL5SWEBew5ShlquNxg==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "optionalDependencies": {+ "graceful-fs": "^4.1.6"+ }+ },+ "node_modules/electron-winstaller/node_modules/universalify": {+ "version": "0.1.2",+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-0.1.2.tgz",+ "integrity": "sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "engines": {+ "node": ">= 4.0.0"+ }+ },+ "node_modules/electron/node_modules/@types/node": {+ "version": "24.13.3",+ "resolved": "https://registry.npmjs.org/@types/node/-/node-24.13.3.tgz",+ "integrity": "sha512-Dh8vAsV36ig5wa9OX4pXvMc9D3Veibfw2wix0CUwYODLD8nkj9UsLjASr49nPg+2eKzxhBV+v7L8pXvT4e639Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "undici-types": "~7.18.0"+ }+ },+ "node_modules/electron/node_modules/undici-types": {+ "version": "7.18.2",+ "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",+ "integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",+ "dev": true,+ "license": "MIT"+ },"node_modules/emoji-regex": {"version": "9.2.2","resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-9.2.2.tgz",@@ -9838,6 +11162,16 @@"node": ">= 0.8"}},+ "node_modules/end-of-stream": {+ "version": "1.4.5",+ "resolved": "https://registry.npmjs.org/end-of-stream/-/end-of-stream-1.4.5.tgz",+ "integrity": "sha512-ooEGc6HP26xXq/N+GCGOT0JKCLDGrq2bQUZrQ7gyrJiZANJ/8YDTxTpQBXGMn+WbIQXNVpyWymm7KYVICQnyOg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "once": "^1.4.0"+ }+ },"node_modules/engine.io-client": {"version": "6.6.5","resolved": "https://registry.npmjs.org/engine.io-client/-/engine.io-client-6.6.5.tgz",@@ -9899,12 +11233,25 @@"resolved": "https://registry.npmjs.org/entities/-/entities-8.0.0.tgz","integrity": "sha512-zwfzJecQ/Uej6tusMqwAqU/6KL2XaB2VZ2Jg54Je6ahNBGNH6Ek6g3jjNCF0fG9EWQKGZNddNjU5F1ZQn/sBnA==","dev": true,- "license": "BSD-2-Clause",+ "license": "BSD-2-Clause",+ "engines": {+ "node": ">=20.19.0"+ },+ "funding": {+ "url": "https://github.com/fb55/entities?sponsor=1"+ }+ },+ "node_modules/env-paths": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-3.0.0.tgz",+ "integrity": "sha512-dtJUTepzMW3Lm/NPxRf3wP4642UWhjL2sQxc+ym2YMj1m/H2zDNQOlezafzkHwn6sMstjHTwG6iQQsctDW/b1A==",+ "dev": true,+ "license": "MIT","engines": {- "node": ">=20.19.0"+ "node": "^12.20.0 || ^14.13.1 || >=16.0.0"},"funding": {- "url": "https://github.com/fb55/entities?sponsor=1"+ "url": "https://github.com/sponsors/sindresorhus"}},"node_modules/environment": {@@ -9920,6 +11267,13 @@"url": "https://github.com/sponsors/sindresorhus"}},+ "node_modules/err-code": {+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/err-code/-/err-code-2.0.3.tgz",+ "integrity": "sha512-2bmlRpNKBxT/CRmPOlyISQpNj+qSeYvcym/uT0Jx2bMOlKLtSy1ZmLuVxSEKKyor/N5yhvp/ZiG1oE3DEYMSFA==",+ "dev": true,+ "license": "MIT"+ },"node_modules/error-ex": {"version": "1.3.4","resolved": "https://registry.npmjs.org/error-ex/-/error-ex-1.3.4.tgz",@@ -10117,6 +11471,14 @@"url": "https://github.com/sponsors/ljharb"}},+ "node_modules/es6-error": {+ "version": "4.1.1",+ "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",+ "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },"node_modules/esbuild": {"version": "0.27.7","resolved": "https://registry.npmjs.org/esbuild/-/esbuild-0.27.7.tgz",@@ -10781,6 +12143,13 @@"node": ">=12.0.0"}},+ "node_modules/exponential-backoff": {+ "version": "3.1.3",+ "resolved": "https://registry.npmjs.org/exponential-backoff/-/exponential-backoff-3.1.3.tgz",+ "integrity": "sha512-ZgEeZXj30q+I0EN+CbSSpIyPaJ5HVQD18Z1m+u1FXbAeT94mr1zw50q4q6jiiC447Nl/YTcIYSAftiGqetwXCA==",+ "dev": true,+ "license": "Apache-2.0"+ },"node_modules/express": {"version": "4.22.2","resolved": "https://registry.npmjs.org/express/-/express-4.22.2.tgz",@@ -10855,6 +12224,38 @@"integrity": "sha512-fjquC59cD7CyW6urNXK0FBufkZcoiGG80wTuPujX590cB5Ttln20E2UB4S/WARVqhXffZl2LNgS+gQdPIIim/g==","license": "MIT"},+ "node_modules/extract-zip": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/extract-zip/-/extract-zip-2.0.1.tgz",+ "integrity": "sha512-GDhU9ntwuKyGXdZBUgTIe+vXnWj0fppUEtMDL0+idd5Sta8TGpHssn/eusA9mrPr9qNDym6SxAYZjNvCn/9RBg==",+ "dev": true,+ "license": "BSD-2-Clause",+ "dependencies": {+ "debug": "^4.1.1",+ "get-stream": "^5.1.0",+ "yauzl": "^2.10.0"+ },+ "bin": {+ "extract-zip": "cli.js"+ },+ "engines": {+ "node": ">= 10.17.0"+ },+ "optionalDependencies": {+ "@types/yauzl": "^2.9.1"+ }+ },+ "node_modules/extsprintf": {+ "version": "1.4.1",+ "resolved": "https://registry.npmjs.org/extsprintf/-/extsprintf-1.4.1.tgz",+ "integrity": "sha512-Wrk35e8ydCKDj/ArClo1VrPVmN8zph5V4AtHwIuHhvMXsKf73UT3BOD+azBIW+3wOJ4FhEH7zyaJCFvChjYvMA==",+ "dev": true,+ "engines": [+ "node >=0.6.0"+ ],+ "license": "MIT",+ "optional": true+ },"node_modules/fast-deep-equal": {"version": "3.1.3","resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",@@ -10980,6 +12381,16 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/fd-slicer": {+ "version": "1.1.0",+ "resolved": "https://registry.npmjs.org/fd-slicer/-/fd-slicer-1.1.0.tgz",+ "integrity": "sha512-cE1qsB/VwyQozZ+q1dGxR8LBYNZeofhEdUNGSMbQD3Gw2lAzX9Zb3uIU6Ebc/Fmyjo9AWWfnn0AUCHqtevs/8g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "pend": "~1.2.0"+ }+ },"node_modules/fdir": {"version": "6.5.0","resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",@@ -11031,6 +12442,39 @@"moment": "^2.29.1"}},+ "node_modules/filelist": {+ "version": "1.0.6",+ "resolved": "https://registry.npmjs.org/filelist/-/filelist-1.0.6.tgz",+ "integrity": "sha512-5giy2PkLYY1cP39p17Ech+2xlpTRL9HLspOfEgm0L6CwBXBTgsK5ou0JtzYuepxkaQ/tvhCFIJ5uXo0OrM2DxA==",+ "dev": true,+ "license": "Apache-2.0",+ "dependencies": {+ "minimatch": "^5.0.1"+ }+ },+ "node_modules/filelist/node_modules/brace-expansion": {+ "version": "2.1.2",+ "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.1.2.tgz",+ "integrity": "sha512-w5JZcKgdhDOgOwm8H+KgbosopHMuGcl6qbulwjtz3SM7I7P3yW1eAjzMPLrIE+NQ9vjgANKHWeMHnrT0OXW1oA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "balanced-match": "^1.0.0"+ }+ },+ "node_modules/filelist/node_modules/minimatch": {+ "version": "5.1.9",+ "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-5.1.9.tgz",+ "integrity": "sha512-7o1wEA2RyMP7Iu7GNba9vc0RWWGACJOCZBJX2GJWip0ikV+wcOsgVuY9uE8CPiyQhkGFSlhuSkZPavN7u1c2Fw==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "brace-expansion": "^2.0.1"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/fill-range": {"version": "7.1.1","resolved": "https://registry.npmjs.org/fill-range/-/fill-range-7.1.1.tgz",@@ -11226,6 +12670,28 @@"node": ">= 0.6"}},+ "node_modules/fs-extra": {+ "version": "10.1.0",+ "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",+ "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "graceful-fs": "^4.2.0",+ "jsonfile": "^6.0.1",+ "universalify": "^2.0.0"+ },+ "engines": {+ "node": ">=12"+ }+ },+ "node_modules/fs.realpath": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",+ "integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",+ "dev": true,+ "license": "ISC"+ },"node_modules/fsevents": {"version": "2.3.2","resolved": "https://registry.npmjs.org/fsevents/-/fsevents-2.3.2.tgz",@@ -11373,6 +12839,22 @@"node": ">= 0.4"}},+ "node_modules/get-stream": {+ "version": "5.2.0",+ "resolved": "https://registry.npmjs.org/get-stream/-/get-stream-5.2.0.tgz",+ "integrity": "sha512-nBF+F1rAZVCu/p7rjzgA+Yb4lfYXrpl7a6VmJrU8wF9I1CKvP/QwPNZHnOlwbTkY6dvtFIzFMSyQXbLoTQPRpA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "pump": "^3.0.0"+ },+ "engines": {+ "node": ">=8"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/get-symbol-description": {"version": "1.1.0","resolved": "https://registry.npmjs.org/get-symbol-description/-/get-symbol-description-1.1.0.tgz",@@ -11404,6 +12886,28 @@"url": "https://github.com/privatenumber/get-tsconfig?sponsor=1"}},+ "node_modules/glob": {+ "version": "7.2.3",+ "resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",+ "integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",+ "deprecated": "Old versions of glob are not supported, and contain widely publicized security vulnerabilities, which have been fixed in the current version. Please update. Support for old versions may be purchased (at exorbitant rates) by contacting [email protected]",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "fs.realpath": "^1.0.0",+ "inflight": "^1.0.4",+ "inherits": "2",+ "minimatch": "^3.1.1",+ "once": "^1.3.0",+ "path-is-absolute": "^1.0.0"+ },+ "engines": {+ "node": "*"+ },+ "funding": {+ "url": "https://github.com/sponsors/isaacs"+ }+ },"node_modules/glob-parent": {"version": "6.0.2","resolved": "https://registry.npmjs.org/glob-parent/-/glob-parent-6.0.2.tgz",@@ -11417,6 +12921,25 @@"node": ">=10.13.0"}},+ "node_modules/global-agent": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",+ "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",+ "dev": true,+ "license": "BSD-3-Clause",+ "optional": true,+ "dependencies": {+ "boolean": "^3.0.1",+ "es6-error": "^4.1.1",+ "matcher": "^3.0.0",+ "roarr": "^2.15.3",+ "semver": "^7.3.2",+ "serialize-error": "^7.0.1"+ },+ "engines": {+ "node": ">=10.0"+ }+ },"node_modules/globals": {"version": "16.5.0","resolved": "https://registry.npmjs.org/globals/-/globals-16.5.0.tgz",@@ -11468,6 +12991,32 @@"url": "https://github.com/sponsors/ljharb"}},+ "node_modules/got": {+ "version": "11.8.6",+ "resolved": "https://registry.npmjs.org/got/-/got-11.8.6.tgz",+ "integrity": "sha512-6tfZ91bOr7bOXnK7PRDCGBLa1H4U080YHNaAQ2KsMGlLEzRbk44nsZF2E1IeRc3vtJHPVbKCYgdFbaGO2ljd8g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@sindresorhus/is": "^4.0.0",+ "@szmarczak/http-timer": "^4.0.5",+ "@types/cacheable-request": "^6.0.1",+ "@types/responselike": "^1.0.0",+ "cacheable-lookup": "^5.0.3",+ "cacheable-request": "^7.0.2",+ "decompress-response": "^6.0.0",+ "http2-wrapper": "^1.0.0-beta.5.2",+ "lowercase-keys": "^2.0.0",+ "p-cancelable": "^2.0.0",+ "responselike": "^2.0.0"+ },+ "engines": {+ "node": ">=10.19.0"+ },+ "funding": {+ "url": "https://github.com/sindresorhus/got?sponsor=1"+ }+ },"node_modules/graceful-fs": {"version": "4.2.11","resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",@@ -11791,6 +13340,39 @@"integrity": "sha512-PDEfEF102G23vHmPhLyPboFCD+BkMGu+GuJe2d9/eH4FsCwvgBpnc9n0pGE+ffKdph38s6foEZiEjdgHdzp+IA==","license": "CC0-1.0"},+ "node_modules/hosted-git-info": {+ "version": "4.1.0",+ "resolved": "https://registry.npmjs.org/hosted-git-info/-/hosted-git-info-4.1.0.tgz",+ "integrity": "sha512-kyCuEOWjJqZuDbRHzL8V93NzQhwIB71oFWSyzVo+KPZI+pnQPPxucdkrOZvkLRnrf5URsQM+IJ09Dw29cRALIA==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "lru-cache": "^6.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/hosted-git-info/node_modules/lru-cache": {+ "version": "6.0.0",+ "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-6.0.0.tgz",+ "integrity": "sha512-Jo6dJ04CmSjuznwJSS3pUeWmd/H0ffTlkXXgwZi+eq1UCmqQwCh+eLsYOYCwY991i2Fah4h1BEMCx4qThGbsiA==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "yallist": "^4.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },+ "node_modules/hosted-git-info/node_modules/yallist": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-4.0.0.tgz",+ "integrity": "sha512-3wdGidZyq5PB084XLES5TpOSRA3wjXAlIWMhum2kRcv/41Sn2emQ0dycQW4uZXLejwKvg6EsvbdlVL+FYEct7A==",+ "dev": true,+ "license": "ISC"+ },"node_modules/html-encoding-sniffer": {"version": "6.0.0","resolved": "https://registry.npmjs.org/html-encoding-sniffer/-/html-encoding-sniffer-6.0.0.tgz",@@ -11840,6 +13422,13 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/http-cache-semantics": {+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/http-cache-semantics/-/http-cache-semantics-4.2.0.tgz",+ "integrity": "sha512-dTxcvPXqPvXBQpq5dUr6mEMJX4oIEFv6bwom3FDwKRDsuIjjJGANqhBuoAn9c1RQJIdAKav33ED65E2ys+87QQ==",+ "dev": true,+ "license": "BSD-2-Clause"+ },"node_modules/http-errors": {"version": "2.0.1","resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.1.tgz",@@ -11860,6 +13449,48 @@"url": "https://opencollective.com/express"}},+ "node_modules/http-proxy-agent": {+ "version": "7.0.2",+ "resolved": "https://registry.npmjs.org/http-proxy-agent/-/http-proxy-agent-7.0.2.tgz",+ "integrity": "sha512-T1gkAiYYDWYx3V5Bmyu7HcfcvL7mUrTWiM6yOfa3PIphViJ/gFPbvidQ+veqSOHci/PxBcDabeUNCzpOODJZig==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "agent-base": "^7.1.0",+ "debug": "^4.3.4"+ },+ "engines": {+ "node": ">= 14"+ }+ },+ "node_modules/http2-wrapper": {+ "version": "1.0.3",+ "resolved": "https://registry.npmjs.org/http2-wrapper/-/http2-wrapper-1.0.3.tgz",+ "integrity": "sha512-V+23sDMr12Wnz7iTcDeJr3O6AIxlnvT/bmaAAAP/Xda35C90p9599p0F1eHR/N1KILWSoWVAiOMFjBBXaXSMxg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "quick-lru": "^5.1.1",+ "resolve-alpn": "^1.0.0"+ },+ "engines": {+ "node": ">=10.19.0"+ }+ },+ "node_modules/https-proxy-agent": {+ "version": "7.0.6",+ "resolved": "https://registry.npmjs.org/https-proxy-agent/-/https-proxy-agent-7.0.6.tgz",+ "integrity": "sha512-vK9P5/iUfdl95AI+JVyUuIcVtd4ofvtrOr3HNtM2yxC9bnMbEdp3x01OhQNnjb8IJYi38VlTE3mBXwcfvywuSw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "agent-base": "^7.1.2",+ "debug": "4"+ },+ "engines": {+ "node": ">= 14"+ }+ },"node_modules/httpxy": {"version": "0.5.3","resolved": "https://registry.npmjs.org/httpxy/-/httpxy-0.5.3.tgz",@@ -11928,6 +13559,107 @@"node": ">=18"}},+ "node_modules/iconv-corefoundation": {+ "version": "1.1.7",+ "resolved": "https://registry.npmjs.org/iconv-corefoundation/-/iconv-corefoundation-1.1.7.tgz",+ "integrity": "sha512-T10qvkw0zz4wnm560lOEg0PovVqUXuOFhhHAkixw8/sycy7TJt7v/RrkEKEQnAw2viPSJu6iAkErxnzR0g8PpQ==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "os": [+ "darwin"+ ],+ "dependencies": {+ "cli-truncate": "^2.1.0",+ "node-addon-api": "^1.6.3"+ },+ "engines": {+ "node": "^8.11.2 || >=10"+ }+ },+ "node_modules/iconv-corefoundation/node_modules/cli-truncate": {+ "version": "2.1.0",+ "resolved": "https://registry.npmjs.org/cli-truncate/-/cli-truncate-2.1.0.tgz",+ "integrity": "sha512-n8fOixwDD6b/ObinzTrp1ZKFzbgvKZvuz/TvejnLn1aQfC6r52XEx85FmuC+3HI+JM7coBRXUvNqEU2PHVrHpg==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "slice-ansi": "^3.0.0",+ "string-width": "^4.2.0"+ },+ "engines": {+ "node": ">=8"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/iconv-corefoundation/node_modules/emoji-regex": {+ "version": "8.0.0",+ "resolved": "https://registry.npmjs.org/emoji-regex/-/emoji-regex-8.0.0.tgz",+ "integrity": "sha512-MSjYzcWNOA0ewAHpz0MxpYFvwg6yjy1NG3xteoqz644VCo/RPgnr1/GGt+ic3iJTzQ8Eu3TdM14SawnVUmGE6A==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },+ "node_modules/iconv-corefoundation/node_modules/is-fullwidth-code-point": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/is-fullwidth-code-point/-/is-fullwidth-code-point-3.0.0.tgz",+ "integrity": "sha512-zymm5+u+sCsSWyD9qNaejV3DFvhCKclKdizYaJUuHA83RLjb7nSuGnddCHGv0hk+KY7BMAlsWeK4Ueg6EV6XQg==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/iconv-corefoundation/node_modules/slice-ansi": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/slice-ansi/-/slice-ansi-3.0.0.tgz",+ "integrity": "sha512-pSyv7bSTC7ig9Dcgbw9AuRNUb5k5V6oDudjZoMBSr13qpLBG7tB+zgCkARjq7xIUgdz5P1Qe8u+rSGdouOOIyQ==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "ansi-styles": "^4.0.0",+ "astral-regex": "^2.0.0",+ "is-fullwidth-code-point": "^3.0.0"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/iconv-corefoundation/node_modules/string-width": {+ "version": "4.2.3",+ "resolved": "https://registry.npmjs.org/string-width/-/string-width-4.2.3.tgz",+ "integrity": "sha512-wKyQRQpjJ0sIp62ErSZdGsjMJWsap5oRNihHhu6G7JVO/9jIB6UyevL+tXuOqrng8j/cxKTWyWUwvSTriiZz/g==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "emoji-regex": "^8.0.0",+ "is-fullwidth-code-point": "^3.0.0",+ "strip-ansi": "^6.0.1"+ },+ "engines": {+ "node": ">=8"+ }+ },+ "node_modules/iconv-corefoundation/node_modules/strip-ansi": {+ "version": "6.0.1",+ "resolved": "https://registry.npmjs.org/strip-ansi/-/strip-ansi-6.0.1.tgz",+ "integrity": "sha512-Y38VPSHcqkFrCpFnQ9vuSXmquuv5oXOKpGeT6aGrr3o3Gc9AlVa6JBfUSOCnbxGGZF+/0ooI7KrPuUSztUdU5A==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "ansi-regex": "^5.0.1"+ },+ "engines": {+ "node": ">=8"+ }+ },"node_modules/iconv-lite": {"version": "0.4.24","resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",@@ -11940,6 +13672,28 @@"node": ">=0.10.0"}},+ "node_modules/ieee754": {+ "version": "1.2.1",+ "resolved": "https://registry.npmjs.org/ieee754/-/ieee754-1.2.1.tgz",+ "integrity": "sha512-dcyqhDvX1C46lXZcVqCpK+FtMRQVdIMN6/Df5js2zouUsqG7I6sFxitIC+7KYK29KdXOLHdu9zL4sFnoVQnqaA==",+ "dev": true,+ "funding": [+ {+ "type": "github",+ "url": "https://github.com/sponsors/feross"+ },+ {+ "type": "patreon",+ "url": "https://www.patreon.com/feross"+ },+ {+ "type": "consulting",+ "url": "https://feross.org/support"+ }+ ],+ "license": "BSD-3-Clause",+ "optional": true+ },"node_modules/ignore": {"version": "5.3.2","resolved": "https://registry.npmjs.org/ignore/-/ignore-5.3.2.tgz",@@ -11987,6 +13741,18 @@"node": ">=8"}},+ "node_modules/inflight": {+ "version": "1.0.6",+ "resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",+ "integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",+ "deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "once": "^1.3.0",+ "wrappy": "1"+ }+ },"node_modules/inherits": {"version": "2.0.4","resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",@@ -12558,6 +14324,19 @@"dev": true,"license": "MIT"},+ "node_modules/isbinaryfile": {+ "version": "5.0.7",+ "resolved": "https://registry.npmjs.org/isbinaryfile/-/isbinaryfile-5.0.7.tgz",+ "integrity": "sha512-gnWD14Jh3FzS3CPhF0AxNOJ8CxqeblPTADzI38r0wt8ZyQl5edpy75myt08EG2oKvpyiqSqsx+Wkz9vtkbTqYQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 18.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/gjtorikian/"+ }+ },"node_modules/isbot": {"version": "5.1.39","resolved": "https://registry.npmjs.org/isbot/-/isbot-5.1.39.tgz",@@ -12631,6 +14410,24 @@"node": ">= 0.4"}},+ "node_modules/jake": {+ "version": "10.9.4",+ "resolved": "https://registry.npmjs.org/jake/-/jake-10.9.4.tgz",+ "integrity": "sha512-wpHYzhxiVQL+IV05BLE2Xn34zW1S223hvjtqk0+gsPrwd/8JNLXJgZZM/iPFsYc1xyphF+6M6EvdE5E9MBGkDA==",+ "dev": true,+ "license": "Apache-2.0",+ "dependencies": {+ "async": "^3.2.6",+ "filelist": "^1.0.4",+ "picocolors": "^1.1.1"+ },+ "bin": {+ "jake": "bin/cli.js"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/jiti": {"version": "2.7.0","resolved": "https://registry.npmjs.org/jiti/-/jiti-2.7.0.tgz",@@ -12772,6 +14569,14 @@"dev": true,"license": "MIT"},+ "node_modules/json-stringify-safe": {+ "version": "5.0.1",+ "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",+ "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",+ "dev": true,+ "license": "ISC",+ "optional": true+ },"node_modules/json5": {"version": "2.2.3","resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",@@ -12785,6 +14590,19 @@"node": ">=6"}},+ "node_modules/jsonfile": {+ "version": "6.2.1",+ "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",+ "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "universalify": "^2.0.0"+ },+ "optionalDependencies": {+ "graceful-fs": "^4.1.6"+ }+ },"node_modules/jsx-ast-utils": {"version": "3.3.5","resolved": "https://registry.npmjs.org/jsx-ast-utils/-/jsx-ast-utils-3.3.5.tgz",@@ -12846,6 +14664,13 @@"node": ">=0.10"}},+ "node_modules/lazy-val": {+ "version": "1.0.5",+ "resolved": "https://registry.npmjs.org/lazy-val/-/lazy-val-1.0.5.tgz",+ "integrity": "sha512-0/BnGCCfyUMkBpeDgWihanIAF9JmZhHBgUhEqzvf+adhNGLoP6TaiI5oF8oyb3I45P+PcnrqihSf01M0l0G5+Q==",+ "dev": true,+ "license": "MIT"+ },"node_modules/levn": {"version": "0.4.1","resolved": "https://registry.npmjs.org/levn/-/levn-0.4.1.tgz",@@ -13308,6 +15133,16 @@"tslib": "^2.0.3"}},+ "node_modules/lowercase-keys": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/lowercase-keys/-/lowercase-keys-2.0.0.tgz",+ "integrity": "sha512-tqNXrS78oMOE73NMxK4EMLQsQowWf8jKooH9g7xPavRT706R6bkQJ6DY2Te7QukaZsulxa30wQ7bk0pm4XiHmA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },"node_modules/lowlight": {"version": "1.20.0","resolved": "https://registry.npmjs.org/lowlight/-/lowlight-1.20.0.tgz",@@ -13410,6 +15245,20 @@"node": ">= 18"}},+ "node_modules/matcher": {+ "version": "3.0.0",+ "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",+ "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "escape-string-regexp": "^4.0.0"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/math-intrinsics": {"version": "1.1.0","resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",@@ -14404,6 +16253,16 @@"url": "https://github.com/sponsors/sindresorhus"}},+ "node_modules/mimic-response": {+ "version": "1.0.1",+ "resolved": "https://registry.npmjs.org/mimic-response/-/mimic-response-1.0.1.tgz",+ "integrity": "sha512-j5EctnkH7amfV/q5Hgmoal1g2QHFJRraOtmx0JpIqkxhBhI/lJSl1nMpQ45hVarwNETOoWEimndZ4QK0RHxuxQ==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=4"+ }+ },"node_modules/min-indent": {"version": "1.0.1","resolved": "https://registry.npmjs.org/min-indent/-/min-indent-1.0.1.tgz",@@ -14427,6 +16286,39 @@"node": "*"}},+ "node_modules/minimist": {+ "version": "1.2.8",+ "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",+ "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",+ "dev": true,+ "license": "MIT",+ "funding": {+ "url": "https://github.com/sponsors/ljharb"+ }+ },+ "node_modules/minipass": {+ "version": "7.1.3",+ "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",+ "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=16 || 14 >=14.17"+ }+ },+ "node_modules/minizlib": {+ "version": "3.1.0",+ "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",+ "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "minipass": "^7.1.2"+ },+ "engines": {+ "node": ">= 18"+ }+ },"node_modules/mkdirp": {"version": "1.0.4","resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-1.0.4.tgz",@@ -14702,6 +16594,37 @@"tslib": "^2.0.3"}},+ "node_modules/node-abi": {+ "version": "4.33.0",+ "resolved": "https://registry.npmjs.org/node-abi/-/node-abi-4.33.0.tgz",+ "integrity": "sha512-vLBWCKb+7LWsX+TbfzWOkw0W81m377tyx3hOweBTjO43CXZnRGS1/JPWs20fr0PgZyDXk6ROYrylsEycK8raDA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "semver": "^7.6.3"+ },+ "engines": {+ "node": ">=22.12.0"+ }+ },+ "node_modules/node-addon-api": {+ "version": "1.7.2",+ "resolved": "https://registry.npmjs.org/node-addon-api/-/node-addon-api-1.7.2.tgz",+ "integrity": "sha512-ibPK3iA+vaY1eEjESkQkM0BbCqFOaZMiXRTtdB0u7b4djtY6JnsjvPdUHVMg6xQt3B8fpTTWHI9A+ADjM9frzg==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },+ "node_modules/node-api-version": {+ "version": "0.2.1",+ "resolved": "https://registry.npmjs.org/node-api-version/-/node-api-version-0.2.1.tgz",+ "integrity": "sha512-2xP/IGGMmmSQpI1+O/k72jF/ykvZ89JeuKX3TLJAYPDVLUalrshrLHkeVcCCZqG/eEa635cr8IBYzgnDvM2O8Q==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "semver": "^7.3.5"+ }+ },"node_modules/node-exports-info": {"version": "1.6.0","resolved": "https://registry.npmjs.org/node-exports-info/-/node-exports-info-1.6.0.tgz",@@ -14731,6 +16654,77 @@"semver": "bin/semver.js"}},+ "node_modules/node-gyp": {+ "version": "12.4.0",+ "resolved": "https://registry.npmjs.org/node-gyp/-/node-gyp-12.4.0.tgz",+ "integrity": "sha512-OMcPNvqTCFUnNaBlmdgq+lfNqY7gTiSmNRDjY3uAXRyudeKZEZxu3CLtjMQrx4zZxCX2b/mpNqTtwuCJgXhHkw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "env-paths": "^2.2.0",+ "exponential-backoff": "^3.1.1",+ "graceful-fs": "^4.2.6",+ "nopt": "^9.0.0",+ "proc-log": "^6.0.0",+ "semver": "^7.3.5",+ "tar": "^7.5.4",+ "tinyglobby": "^0.2.12",+ "undici": "^6.25.0",+ "which": "^6.0.0"+ },+ "bin": {+ "node-gyp": "bin/node-gyp.js"+ },+ "engines": {+ "node": "^20.17.0 || >=22.9.0"+ }+ },+ "node_modules/node-gyp/node_modules/env-paths": {+ "version": "2.2.1",+ "resolved": "https://registry.npmjs.org/env-paths/-/env-paths-2.2.1.tgz",+ "integrity": "sha512-+h1lkLKhZMTYjog1VEpJNG7NZJWcuc2DDk/qsqSTRRCOXiLjeQ1d1/udrUGhqMxUgAlwKNZ0cf2uqan5GLuS2A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=6"+ }+ },+ "node_modules/node-gyp/node_modules/isexe": {+ "version": "4.0.0",+ "resolved": "https://registry.npmjs.org/isexe/-/isexe-4.0.0.tgz",+ "integrity": "sha512-FFUtZMpoZ8RqHS3XeXEmHWLA4thH+ZxCv2lOiPIn1Xc7CxrqhWzNSDzD+/chS/zbYezmiwWLdQC09JdQKmthOw==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=20"+ }+ },+ "node_modules/node-gyp/node_modules/undici": {+ "version": "6.27.0",+ "resolved": "https://registry.npmjs.org/undici/-/undici-6.27.0.tgz",+ "integrity": "sha512-YmfV3YnEDzXRC5lZ2jWtWWHKGUm1zIt8AhesR1tens+HTNv+YZlN/dp6G727LOvMJ8xjP9Be7Y2Sdr96LDm+pg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=18.17"+ }+ },+ "node_modules/node-gyp/node_modules/which": {+ "version": "6.0.1",+ "resolved": "https://registry.npmjs.org/which/-/which-6.0.1.tgz",+ "integrity": "sha512-oGLe46MIrCRqX7ytPUf66EAYvdeMIZYn3WaocqqKZAxrBpkqHfL/qvTyJ/bTk5+AqHCjXmrv3CEWgy368zhRUg==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "isexe": "^4.0.0"+ },+ "bin": {+ "node-which": "bin/which.js"+ },+ "engines": {+ "node": "^20.17.0 || >=22.9.0"+ }+ },"node_modules/node-releases": {"version": "2.0.47","resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.47.tgz",@@ -14741,6 +16735,35 @@"node": ">=18"}},+ "node_modules/nopt": {+ "version": "9.0.0",+ "resolved": "https://registry.npmjs.org/nopt/-/nopt-9.0.0.tgz",+ "integrity": "sha512-Zhq3a+yFKrYwSBluL4H9XP3m3y5uvQkB/09CwDruCiRmR/UJYnn9W4R48ry0uGC70aeTPKLynBtscP9efFFcPw==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "abbrev": "^4.0.0"+ },+ "bin": {+ "nopt": "bin/nopt.js"+ },+ "engines": {+ "node": "^20.17.0 || >=22.9.0"+ }+ },+ "node_modules/normalize-url": {+ "version": "6.1.0",+ "resolved": "https://registry.npmjs.org/normalize-url/-/normalize-url-6.1.0.tgz",+ "integrity": "sha512-DlL+XwOy3NxAQ8xuC0okPgK46iuVNAK01YN7RueYBqqFeGsBjV9XmCAzAdgt+667bCl5kPh9EqKKDwnaPG1I7A==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/object-assign": {"version": "4.1.1","resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",@@ -14891,6 +16914,16 @@"node": ">= 0.8"}},+ "node_modules/once": {+ "version": "1.4.0",+ "resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",+ "integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",+ "dev": true,+ "license": "ISC",+ "dependencies": {+ "wrappy": "1"+ }+ },"node_modules/one-time": {"version": "1.0.0","resolved": "https://registry.npmjs.org/one-time/-/one-time-1.0.0.tgz",@@ -14959,6 +16992,16 @@"url": "https://github.com/sponsors/ljharb"}},+ "node_modules/p-cancelable": {+ "version": "2.1.1",+ "resolved": "https://registry.npmjs.org/p-cancelable/-/p-cancelable-2.1.1.tgz",+ "integrity": "sha512-BZOr3nRQHOntUjTrH8+Lh54smKHoHyur8We1V8DSMVrl5A2malOOwuJRnKRDjSnkoeBh4at6BwEnb5I7Jl31wg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8"+ }+ },"node_modules/p-limit": {"version": "3.1.0","resolved": "https://registry.npmjs.org/p-limit/-/p-limit-3.1.0.tgz",@@ -15100,6 +17143,16 @@"node": ">=8"}},+ "node_modules/path-is-absolute": {+ "version": "1.0.1",+ "resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",+ "integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=0.10.0"+ }+ },"node_modules/path-key": {"version": "3.1.1","resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",@@ -15140,6 +17193,28 @@"dev": true,"license": "MIT"},+ "node_modules/pe-library": {+ "version": "0.4.1",+ "resolved": "https://registry.npmjs.org/pe-library/-/pe-library-0.4.1.tgz",+ "integrity": "sha512-eRWB5LBz7PpDu4PUlwT0PhnQfTQJlDDdPa35urV4Osrm0t0AqQFGn+UIkU3klZvwJ8KPO3VbBFsXquA6p6kqZw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=12",+ "npm": ">=6"+ },+ "funding": {+ "type": "github",+ "url": "https://github.com/sponsors/jet2jet"+ }+ },+ "node_modules/pend": {+ "version": "1.2.0",+ "resolved": "https://registry.npmjs.org/pend/-/pend-1.2.0.tgz",+ "integrity": "sha512-F3asv42UuXchdzt+xXqfW1OGlVBe+mxa2mqI0pg5yAHZPvFmY3Y6drSf/GQ1A86WgWEN9Kzh/WrgKa6iGcHXLg==",+ "dev": true,+ "license": "MIT"+ },"node_modules/picocolors": {"version": "1.1.1","resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",@@ -15209,6 +17284,21 @@"node": ">=18"}},+ "node_modules/plist": {+ "version": "3.1.0",+ "resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz",+ "integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "@xmldom/xmldom": "^0.8.8",+ "base64-js": "^1.5.1",+ "xmlbuilder": "^15.1.1"+ },+ "engines": {+ "node": ">=10.4.0"+ }+ },"node_modules/possible-typed-array-names": {"version": "1.1.0","resolved": "https://registry.npmjs.org/possible-typed-array-names/-/possible-typed-array-names-1.1.0.tgz",@@ -15292,6 +17382,36 @@"web-vitals": "^5.1.0"}},+ "node_modules/postject": {+ "version": "1.0.0-alpha.6",+ "resolved": "https://registry.npmjs.org/postject/-/postject-1.0.0-alpha.6.tgz",+ "integrity": "sha512-b9Eb8h2eVqNE8edvKdwqkrY6O7kAwmI8kcnBv1NScolYJbo59XUF0noFq+lxbC1yN20bmC0WBEbDC5H/7ASb0A==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "peer": true,+ "dependencies": {+ "commander": "^9.4.0"+ },+ "bin": {+ "postject": "dist/cli.js"+ },+ "engines": {+ "node": ">=14.0.0"+ }+ },+ "node_modules/postject/node_modules/commander": {+ "version": "9.5.0",+ "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",+ "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "peer": true,+ "engines": {+ "node": "^12.20.0 || >=14"+ }+ },"node_modules/preact": {"version": "10.29.2","resolved": "https://registry.npmjs.org/preact/-/preact-10.29.2.tgz",@@ -15398,6 +17518,40 @@"node": ">=6"}},+ "node_modules/proc-log": {+ "version": "6.1.0",+ "resolved": "https://registry.npmjs.org/proc-log/-/proc-log-6.1.0.tgz",+ "integrity": "sha512-iG+GYldRf2BQ0UDUAd6JQ/RwzaQy6mXmsk/IzlYyal4A4SNFw54MeH4/tLkF4I5WoWG9SQwuqWzS99jaFQHBuQ==",+ "dev": true,+ "license": "ISC",+ "engines": {+ "node": "^20.17.0 || >=22.9.0"+ }+ },+ "node_modules/progress": {+ "version": "2.0.3",+ "resolved": "https://registry.npmjs.org/progress/-/progress-2.0.3.tgz",+ "integrity": "sha512-7PiHtLll5LdnKIMw100I+8xJXR5gW2QwWYkT6iJva0bXitZKa/XMrSbdmg3r2Xnaidz9Qumd0VPaMrZlF9V9sA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=0.4.0"+ }+ },+ "node_modules/promise-retry": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/promise-retry/-/promise-retry-2.0.1.tgz",+ "integrity": "sha512-y+WKFlBR8BGXnsNlIHFGPZmyDf3DFMoLhaflAnyZgV6rG6xu+JwesTo2Q9R6XwYmtmwAFCkAk3e35jEdoeh/3g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "err-code": "^2.0.2",+ "retry": "^0.12.0"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/prop-types": {"version": "15.8.1","resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",@@ -15415,6 +17569,25 @@"integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==","license": "MIT"},+ "node_modules/proper-lockfile": {+ "version": "4.1.2",+ "resolved": "https://registry.npmjs.org/proper-lockfile/-/proper-lockfile-4.1.2.tgz",+ "integrity": "sha512-TjNPblN4BwAWMXU8s9AEz4JmQxnD1NNL7bNOY/AKUzyamc379FWASUhc/K1pL2noVb+XmZKLL68cjzLsiOAMaA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "graceful-fs": "^4.2.4",+ "retry": "^0.12.0",+ "signal-exit": "^3.0.2"+ }+ },+ "node_modules/proper-lockfile/node_modules/signal-exit": {+ "version": "3.0.7",+ "resolved": "https://registry.npmjs.org/signal-exit/-/signal-exit-3.0.7.tgz",+ "integrity": "sha512-wnD2ZE+l+SPC/uoS0vXeE9L1+0wuaMqKlfz9AMUo38JsyLSBWSFcHR1Rri62LZc12vLr1gb3jl7iwQhgwpAbGQ==",+ "dev": true,+ "license": "ISC"+ },"node_modules/property-information": {"version": "7.2.0","resolved": "https://registry.npmjs.org/property-information/-/property-information-7.2.0.tgz",@@ -15471,6 +17644,17 @@"node": ">=10"}},+ "node_modules/pump": {+ "version": "3.0.4",+ "resolved": "https://registry.npmjs.org/pump/-/pump-3.0.4.tgz",+ "integrity": "sha512-VS7sjc6KR7e1ukRFhQSY5LM2uBWAUPiOPa/A3mkKmiMwSmRFUITt0xuj+/lesgnCv+dPIEYlkzrcyXgquIHMcA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "end-of-stream": "^1.1.0",+ "once": "^1.3.1"+ }+ },"node_modules/punycode": {"version": "2.3.1","resolved": "https://registry.npmjs.org/punycode/-/punycode-2.3.1.tgz",@@ -15523,6 +17707,19 @@],"license": "MIT"},+ "node_modules/quick-lru": {+ "version": "5.1.1",+ "resolved": "https://registry.npmjs.org/quick-lru/-/quick-lru-5.1.1.tgz",+ "integrity": "sha512-WuyALRjWPDGtt/wzJiadO5AXY+8hZ80hVpe6MyivgraREW751X3SbhRvG3eLKOYN+8VEvqLcf3wdnt44Z4S4SA==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/range-parser": {"version": "1.2.1","resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",@@ -15886,6 +18083,19 @@"react-dom": ">=16.6.0"}},+ "node_modules/read-binary-file-arch": {+ "version": "1.0.6",+ "resolved": "https://registry.npmjs.org/read-binary-file-arch/-/read-binary-file-arch-1.0.6.tgz",+ "integrity": "sha512-BNg9EN3DD3GsDXX7Aa8O4p92sryjkmzYYgmgTAc6CA4uGLEDzFfxOxugu21akOxpcXHiEgsYkC6nPsQvLLLmEg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "debug": "^4.3.4"+ },+ "bin": {+ "read-binary-file-arch": "cli.js"+ }+ },"node_modules/readable-stream": {"version": "3.6.2","resolved": "https://registry.npmjs.org/readable-stream/-/readable-stream-3.6.2.tgz",@@ -16128,6 +18338,24 @@"node": ">=0.10.5"}},+ "node_modules/resedit": {+ "version": "1.7.2",+ "resolved": "https://registry.npmjs.org/resedit/-/resedit-1.7.2.tgz",+ "integrity": "sha512-vHjcY2MlAITJhC0eRD/Vv8Vlgmu9Sd3LX9zZvtGzU5ZImdTN3+d6e/4mnTyV8vEbyf1sgNIrWxhWlrys52OkEA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "pe-library": "^0.4.1"+ },+ "engines": {+ "node": ">=12",+ "npm": ">=6"+ },+ "funding": {+ "type": "github",+ "url": "https://github.com/sponsors/jet2jet"+ }+ },"node_modules/resolve": {"version": "2.0.0-next.7","resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.7.tgz",@@ -16152,6 +18380,13 @@"url": "https://github.com/sponsors/ljharb"}},+ "node_modules/resolve-alpn": {+ "version": "1.2.1",+ "resolved": "https://registry.npmjs.org/resolve-alpn/-/resolve-alpn-1.2.1.tgz",+ "integrity": "sha512-0a1F4l73/ZFZOakJnQ3FvkJ2+gSTQWz/r2KE5OdDY0TxPm5h4GkqkWWfM47T7HsbnOtcJVEF4epCVy6u7Q3K+g==",+ "dev": true,+ "license": "MIT"+ },"node_modules/resolve-from": {"version": "4.0.0","resolved": "https://registry.npmjs.org/resolve-from/-/resolve-from-4.0.0.tgz",@@ -16172,6 +18407,19 @@"url": "https://github.com/privatenumber/resolve-pkg-maps?sponsor=1"}},+ "node_modules/responselike": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/responselike/-/responselike-2.0.1.tgz",+ "integrity": "sha512-4gl03wn3hj1HP3yzgdI7d3lCkF95F21Pz4BPGvKHinyQzALR5CapwC8yIi0Rh58DEMQ/SguC03wFj2k0M/mHhw==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "lowercase-keys": "^2.0.0"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/restore-cursor": {"version": "5.1.0","resolved": "https://registry.npmjs.org/restore-cursor/-/restore-cursor-5.1.0.tgz",@@ -16189,6 +18437,16 @@"url": "https://github.com/sponsors/sindresorhus"}},+ "node_modules/retry": {+ "version": "0.12.0",+ "resolved": "https://registry.npmjs.org/retry/-/retry-0.12.0.tgz",+ "integrity": "sha512-9LkiTwjUh6rT555DtE9rTX+BKByPfrMzEAtnlEtdEwr3Nkffwiihqe2bWADg+OQRjt9gl6ICdmB/ZFDCGAtSow==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 4"+ }+ },"node_modules/rettime": {"version": "0.11.11","resolved": "https://registry.npmjs.org/rettime/-/rettime-0.11.11.tgz",@@ -16214,6 +18472,40 @@"dev": true,"license": "MIT"},+ "node_modules/rimraf": {+ "version": "2.6.3",+ "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-2.6.3.tgz",+ "integrity": "sha512-mwqeW5XsA2qAejG46gYdENaxXjx9onRNCfn7L0duuP4hCuTIi/QO7PDK07KJfp1d+izWPrzEJDcSqBa0OZQriA==",+ "deprecated": "Rimraf versions prior to v4 are no longer supported",+ "dev": true,+ "license": "ISC",+ "peer": true,+ "dependencies": {+ "glob": "^7.1.3"+ },+ "bin": {+ "rimraf": "bin.js"+ }+ },+ "node_modules/roarr": {+ "version": "2.15.4",+ "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",+ "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",+ "dev": true,+ "license": "BSD-3-Clause",+ "optional": true,+ "dependencies": {+ "boolean": "^3.0.1",+ "detect-node": "^2.0.4",+ "globalthis": "^1.0.1",+ "json-stringify-safe": "^5.0.1",+ "semver-compare": "^1.0.0",+ "sprintf-js": "^1.1.2"+ },+ "engines": {+ "node": ">=8.0"+ }+ },"node_modules/rolldown": {"version": "1.0.0-rc.17","resolved": "https://registry.npmjs.org/rolldown/-/rolldown-1.0.0-rc.17.tgz",@@ -16418,6 +18710,26 @@"integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==","license": "MIT"},+ "node_modules/sanitize-filename": {+ "version": "1.6.4",+ "resolved": "https://registry.npmjs.org/sanitize-filename/-/sanitize-filename-1.6.4.tgz",+ "integrity": "sha512-9ZyI08PsvdQl2r/bBIGubpVdR3RR9sY6RDiWFPreA21C/EFlQhmgo20UZlNjZMMZNubusLhAQozkA0Od5J21Eg==",+ "dev": true,+ "license": "WTFPL OR ISC",+ "dependencies": {+ "truncate-utf8-bytes": "^1.0.0"+ }+ },+ "node_modules/sax": {+ "version": "1.6.0",+ "resolved": "https://registry.npmjs.org/sax/-/sax-1.6.0.tgz",+ "integrity": "sha512-6R3J5M4AcbtLUdZmRv2SygeVaM7IhrLXu9BmnOGmmACak8fiUtOsYNWUS4uK7upbmHIBbLBeFeI//477BKLBzA==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=11.0.0"+ }+ },"node_modules/saxes": {"version": "6.0.0","resolved": "https://registry.npmjs.org/saxes/-/saxes-6.0.0.tgz",@@ -16468,6 +18780,14 @@"node": ">=10"}},+ "node_modules/semver-compare": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",+ "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",+ "dev": true,+ "license": "MIT",+ "optional": true+ },"node_modules/send": {"version": "0.19.2","resolved": "https://registry.npmjs.org/send/-/send-0.19.2.tgz",@@ -16507,6 +18827,37 @@"integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==","license": "MIT"},+ "node_modules/serialize-error": {+ "version": "7.0.1",+ "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",+ "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "type-fest": "^0.13.1"+ },+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },+ "node_modules/serialize-error/node_modules/type-fest": {+ "version": "0.13.1",+ "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",+ "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",+ "dev": true,+ "license": "(MIT OR CC0-1.0)",+ "optional": true,+ "engines": {+ "node": ">=10"+ },+ "funding": {+ "url": "https://github.com/sponsors/sindresorhus"+ }+ },"node_modules/serve-static": {"version": "1.16.3","resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.3.tgz",@@ -16720,6 +19071,19 @@"is-arrayish": "^0.3.1"}},+ "node_modules/simple-update-notifier": {+ "version": "2.0.0",+ "resolved": "https://registry.npmjs.org/simple-update-notifier/-/simple-update-notifier-2.0.0.tgz",+ "integrity": "sha512-a2B9Y0KlNXl9u/vsW6sTIu9vGEpfKu2wRV6l1H3XEas/0gUIzGzBoP/IouTcUQbm9JWZLH3COxyn03TYlFax6w==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "semver": "^7.5.3"+ },+ "engines": {+ "node": ">=10"+ }+ },"node_modules/sirv": {"version": "3.0.2","resolved": "https://registry.npmjs.org/sirv/-/sirv-3.0.2.tgz",@@ -16786,6 +19150,18 @@"url": "https://github.com/chalk/ansi-styles?sponsor=1"}},+ "node_modules/smart-buffer": {+ "version": "4.2.0",+ "resolved": "https://registry.npmjs.org/smart-buffer/-/smart-buffer-4.2.0.tgz",+ "integrity": "sha512-94hK0Hh8rPqQl2xXc3HsaBoOXKV20MToPkcXvwbISWLEs+64sBq5kFgn2kJDHb1Pry9yrP0dxrCI9RRci7RXKg==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "engines": {+ "node": ">= 6.0.0",+ "npm": ">= 3.0.0"+ }+ },"node_modules/snake-case": {"version": "3.0.4","resolved": "https://registry.npmjs.org/snake-case/-/snake-case-3.0.4.tgz",@@ -16863,6 +19239,14 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/sprintf-js": {+ "version": "1.1.3",+ "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",+ "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",+ "dev": true,+ "license": "BSD-3-Clause",+ "optional": true+ },"node_modules/stable-hash-x": {"version": "0.2.0","resolved": "https://registry.npmjs.org/stable-hash-x/-/stable-hash-x-0.2.0.tgz",@@ -16889,6 +19273,16 @@"dev": true,"license": "MIT"},+ "node_modules/stat-mode": {+ "version": "1.0.0",+ "resolved": "https://registry.npmjs.org/stat-mode/-/stat-mode-1.0.0.tgz",+ "integrity": "sha512-jH9EhtKIjuXZ2cWxmXS8ZP80XyC3iasQxMDV8jzhNJpfDb7VbQLVW4Wvsxz9QZvzV+G4YoSfBUVKDOyxLzi/sg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 6"+ }+ },"node_modules/state-local": {"version": "1.0.7","resolved": "https://registry.npmjs.org/state-local/-/state-local-1.0.7.tgz",@@ -17168,6 +19562,19 @@"inline-style-parser": "0.2.7"}},+ "node_modules/sumchecker": {+ "version": "3.0.1",+ "resolved": "https://registry.npmjs.org/sumchecker/-/sumchecker-3.0.1.tgz",+ "integrity": "sha512-MvjXzkz/BOfyVDkG0oFOtBxHX2u3gKbMHIF/dXblZsgD3BWOFLmHovIpZY7BykJdAjcqRCBi1WYBNdEC9yI7vg==",+ "dev": true,+ "license": "Apache-2.0",+ "dependencies": {+ "debug": "^4.1.0"+ },+ "engines": {+ "node": ">= 8.0"+ }+ },"node_modules/supports-color": {"version": "7.2.0","resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",@@ -17300,12 +19707,99 @@"url": "https://opencollective.com/webpack"}},+ "node_modules/tar": {+ "version": "7.5.20",+ "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.20.tgz",+ "integrity": "sha512-9FcyK4PA6+WbzlTM9WhQm6vB5W7cP7dUiPsv1g7YDwEQnQ1CGpK3MGlKk/ITVWMk05kHZuBhmVhiv8LZoy/PFQ==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "dependencies": {+ "@isaacs/fs-minipass": "^4.0.0",+ "chownr": "^3.0.0",+ "minipass": "^7.1.2",+ "minizlib": "^3.1.0",+ "yallist": "^5.0.0"+ },+ "engines": {+ "node": ">=18"+ }+ },+ "node_modules/tar/node_modules/yallist": {+ "version": "5.0.0",+ "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",+ "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",+ "dev": true,+ "license": "BlueOak-1.0.0",+ "engines": {+ "node": ">=18"+ }+ },+ "node_modules/temp": {+ "version": "0.9.4",+ "resolved": "https://registry.npmjs.org/temp/-/temp-0.9.4.tgz",+ "integrity": "sha512-yYrrsWnrXMcdsnu/7YMYAofM1ktpL5By7vZhf15CrXijWWrEYZks5AXBudalfSWJLlnen/QUJUB5aoB0kqZUGA==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "mkdirp": "^0.5.1",+ "rimraf": "~2.6.2"+ },+ "engines": {+ "node": ">=6.0.0"+ }+ },+ "node_modules/temp-file": {+ "version": "3.4.0",+ "resolved": "https://registry.npmjs.org/temp-file/-/temp-file-3.4.0.tgz",+ "integrity": "sha512-C5tjlC/HCtVUOi3KWVokd4vHVViOmGjtLwIh4MuzPo/nMYTV/p1urt3RnMz2IWXDdKEGJH3k5+KPxtqRsUYGtg==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "async-exit-hook": "^2.0.1",+ "fs-extra": "^10.0.0"+ }+ },+ "node_modules/temp/node_modules/mkdirp": {+ "version": "0.5.6",+ "resolved": "https://registry.npmjs.org/mkdirp/-/mkdirp-0.5.6.tgz",+ "integrity": "sha512-FP+p8RB8OWpF3YZBCrP5gtADmtXApB5AMLn+vdyA+PyxCjrCs00mjyUozssO33cwDeT3wNGdLxJ5M//YqtHAJw==",+ "dev": true,+ "license": "MIT",+ "peer": true,+ "dependencies": {+ "minimist": "^1.2.6"+ },+ "bin": {+ "mkdirp": "bin/cmd.js"+ }+ },"node_modules/text-hex": {"version": "1.0.0","resolved": "https://registry.npmjs.org/text-hex/-/text-hex-1.0.0.tgz","integrity": "sha512-uuVGNWzgJ4yhRaNSiubPY7OjISw4sw4E5Uv0wbjp+OzcbmVU/rsT8ujgcXJhn9ypzsgr5vlzpPqP+MBBKcGvbg==","license": "MIT"},+ "node_modules/tiny-async-pool": {+ "version": "1.3.0",+ "resolved": "https://registry.npmjs.org/tiny-async-pool/-/tiny-async-pool-1.3.0.tgz",+ "integrity": "sha512-01EAw5EDrcVrdgyCLgoSPvqznC0sVxDSVeiOz09FUpjh71G79VCqneOr+xvt7T1r76CF6ZZfPjHorN2+d+3mqA==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "semver": "^5.5.0"+ }+ },+ "node_modules/tiny-async-pool/node_modules/semver": {+ "version": "5.7.2",+ "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",+ "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",+ "dev": true,+ "license": "ISC",+ "bin": {+ "semver": "bin/semver"+ }+ },"node_modules/tinybench": {"version": "2.9.0","resolved": "https://registry.npmjs.org/tinybench/-/tinybench-2.9.0.tgz",@@ -17378,6 +19872,26 @@"dev": true,"license": "MIT"},+ "node_modules/tmp": {+ "version": "0.2.7",+ "resolved": "https://registry.npmjs.org/tmp/-/tmp-0.2.7.tgz",+ "integrity": "sha512-e0votIpp4Uo2AJYSzVHV6xCcawuiez3DzqDAbrTc3YxBkplN6e+dM13ZeIcZnDg/QpSuU2zfZ3rzwY8ukEnaXw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=14.14"+ }+ },+ "node_modules/tmp-promise": {+ "version": "3.0.3",+ "resolved": "https://registry.npmjs.org/tmp-promise/-/tmp-promise-3.0.3.tgz",+ "integrity": "sha512-RwM7MoPojPxsOBYnyd2hy0bxtIlVrihNs9pj5SUvY8Zz1sQcQG2tG1hSr8PDxfgEB8RNKDhqbIlroIarSNDNsQ==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "tmp": "^0.2.0"+ }+ },"node_modules/to-regex-range": {"version": "5.0.1","resolved": "https://registry.npmjs.org/to-regex-range/-/to-regex-range-5.0.1.tgz",@@ -17464,6 +19978,16 @@"url": "https://github.com/sponsors/wooorm"}},+ "node_modules/truncate-utf8-bytes": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/truncate-utf8-bytes/-/truncate-utf8-bytes-1.0.2.tgz",+ "integrity": "sha512-95Pu1QXQvruGEhv62XCMO3Mm90GscOCClvrIUwCM0PYOXK3kaF3l3sIHxx71ThJfcbM2O5Au6SO3AWCSEfW4mQ==",+ "dev": true,+ "license": "WTFPL",+ "dependencies": {+ "utf8-byte-length": "^1.0.1"+ }+ },"node_modules/ts-api-utils": {"version": "2.5.0","resolved": "https://registry.npmjs.org/ts-api-utils/-/ts-api-utils-2.5.0.tgz",@@ -17757,6 +20281,16 @@"url": "https://opencollective.com/unified"}},+ "node_modules/universalify": {+ "version": "2.0.1",+ "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",+ "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">= 10.0.0"+ }+ },"node_modules/unpipe": {"version": "1.0.0","resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",@@ -17909,6 +20443,13 @@"react": "^16.8.0 || ^17.0.0 || ^18.0.0 || ^19.0.0"}},+ "node_modules/utf8-byte-length": {+ "version": "1.0.5",+ "resolved": "https://registry.npmjs.org/utf8-byte-length/-/utf8-byte-length-1.0.5.tgz",+ "integrity": "sha512-Xn0w3MtiQ6zoz2vFyUVruaCL53O/DwUvkEeOvj+uulMm0BkUGYWmBYVyElqZaSLhY6ZD0ulfU3aBra2aVT4xfA==",+ "dev": true,+ "license": "(WTFPL OR MIT)"+ },"node_modules/util-deprecate": {"version": "1.0.2","resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",@@ -17961,6 +20502,22 @@"node": ">= 0.8"}},+ "node_modules/verror": {+ "version": "1.10.1",+ "resolved": "https://registry.npmjs.org/verror/-/verror-1.10.1.tgz",+ "integrity": "sha512-veufcmxri4e3XSrT0xwfUR7kguIkaxBeosDg00yDWhk49wdwkSUrvvsm7nc75e1PUyvIeZj6nS8VQRYz2/S4Xg==",+ "dev": true,+ "license": "MIT",+ "optional": true,+ "dependencies": {+ "assert-plus": "^1.0.0",+ "core-util-is": "1.0.2",+ "extsprintf": "^1.2.0"+ },+ "engines": {+ "node": ">=0.6.0"+ }+ },"node_modules/vfile": {"version": "6.0.3","resolved": "https://registry.npmjs.org/vfile/-/vfile-6.0.3.tgz",@@ -18648,6 +21205,13 @@"url": "https://github.com/sponsors/sindresorhus"}},+ "node_modules/wrappy": {+ "version": "1.0.2",+ "resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",+ "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",+ "dev": true,+ "license": "ISC"+ },"node_modules/ws": {"version": "8.21.0","resolved": "https://registry.npmjs.org/ws/-/ws-8.21.0.tgz",@@ -18679,6 +21243,16 @@"node": ">=18"}},+ "node_modules/xmlbuilder": {+ "version": "15.1.1",+ "resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",+ "integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",+ "dev": true,+ "license": "MIT",+ "engines": {+ "node": ">=8.0"+ }+ },"node_modules/xmlchars": {"version": "2.2.0","resolved": "https://registry.npmjs.org/xmlchars/-/xmlchars-2.2.0.tgz",@@ -18801,6 +21375,17 @@"node": ">=8"}},+ "node_modules/yauzl": {+ "version": "2.10.0",+ "resolved": "https://registry.npmjs.org/yauzl/-/yauzl-2.10.0.tgz",+ "integrity": "sha512-p4a9I6X6nu6IhoGmBqAcbJy1mlC4j27vEPZX9F4L4/vZT3Lyq1VkFHw/V/PUcB9Buo+DG3iHkT0x3Qya58zc3g==",+ "dev": true,+ "license": "MIT",+ "dependencies": {+ "buffer-crc32": "~0.2.3",+ "fd-slicer": "~1.1.0"+ }+ },"node_modules/yocto-queue": {"version": "0.1.0","resolved": "https://registry.npmjs.org/yocto-queue/-/yocto-queue-0.1.0.tgz",diff --git a/package.json b/package.jsonindex 7edc144c16..e83bc79b35 100644--- a/package.json+++ b/package.json@@ -100,7 +100,12 @@"build:app": "npm run make-i18n && react-router build","build:lib": "npm run make-i18n && react-router typegen && cross-env BUILD_LIB=true vite build && tsc -p tsconfig.lib.json","build:docker": "node scripts/docker-build.mjs",- "example:acp-docker:env": "node scripts/gen-acp-docker-env.mjs"+ "example:acp-docker:env": "node scripts/gen-acp-docker-env.mjs",+ "desktop": "npm run build:app && electron electron/main.mjs",+ "build:desktop": "npm run build:app && node scripts/download-uv.mjs && node scripts/download-node.mjs && electron-builder --config electron-builder.config.mjs",+ "build:desktop:universal": "npm run build:app && node scripts/download-uv.mjs && node scripts/download-node.mjs && cross-env ELECTRON_ARCH=universal electron-builder --config electron-builder.config.mjs",+ "download-uv": "node scripts/download-uv.mjs",+ "download-node": "node scripts/download-node.mjs"},"lint-staged": {"src/**/*.{ts,tsx,js}": [@@ -136,6 +141,8 @@"@vercel/react-router": "1.3.0","@vitest/coverage-v8": "4.1.5","cross-env": "10.1.0",+ "electron": "42.3.2",+ "electron-builder": "26.8.1","eslint": "9.39.4","eslint-config-prettier": "10.1.8","eslint-import-resolver-typescript": "4.4.4",diff --git a/scripts/dev-with-automation.mjs b/scripts/dev-with-automation.mjsindex 705a674e26..e64060c161 100644--- a/scripts/dev-with-automation.mjs+++ b/scripts/dev-with-automation.mjs@@ -546,6 +546,26 @@ const shutdownHooks = createShutdownHookRegistry((err) => {logService("cleanup", `Cleanup hook failed: ${err.message}`, c.yellow);});+// Optional external listener for every service log line. Set by `main()` from+// its `onServiceLog` option so embedded launchers (e.g. the Electron desktop+// app) can stream uvx download / install progress to their loading window+// without touching the terminal logging path. Receives `(name, line, level)`+// where `level` is one of "stdout" | "stderr" | "info" | "warn" | "error".+let serviceLogListener = null;++export function setServiceLogListener(listener) {+ serviceLogListener = typeof listener === "function" ? listener : null;+}++function emitServiceLog(name, line, level) {+ if (!serviceLogListener) return;+ try {+ serviceLogListener(name, line, level);+ } catch {+ // Never let a listener bug crash the dev stack.+ }+}+function registerShutdownHook(hook) {return shutdownHooks.add(hook);}@@ -570,12 +590,14 @@ function spawnService(name, command, args, options = {}) {.split("\n").filter(Boolean).forEach((line) => {- const parsed = parseLogLine ? parseLogLine(line.trim()) : null;+ const trimmed = line.trim();+ const parsed = parseLogLine ? parseLogLine(trimmed) : null;logService(name,- parsed ? parsed.text : line.trim(),+ parsed ? parsed.text : trimmed,parsed ? parsed.color : color,);+ emitServiceLog(name, trimmed, "stdout");});});@@ -585,22 +607,26 @@ function spawnService(name, command, args, options = {}) {.split("\n").filter(Boolean).forEach((line) => {- const parsed = parseLogLine ? parseLogLine(line.trim()) : null;+ const trimmed = line.trim();+ const parsed = parseLogLine ? parseLogLine(trimmed) : null;logService(name,- parsed ? parsed.text : line.trim(),+ parsed ? parsed.text : trimmed,parsed ? parsed.color : c.yellow,);+ emitServiceLog(name, trimmed, "stderr");});});proc.on("error", (error) => {logError(`${name} failed to start: ${error.message}`);+ emitServiceLog(name, `failed to start: ${error.message}`, "error");});proc.on("exit", (code, signal) => {if (code !== 0 && code !== null && !shuttingDown) {logService(name, `Exited with code ${code}`, c.red);+ emitServiceLog(name, `exited with code ${code}`, "error");}processes.delete(name);});@@ -1210,8 +1236,28 @@ async function main(options = {}) {// When true, enable public mode (require LOCAL_BACKEND_API_KEY,// don't bake session key into frontend).isPublic: isPublicOverride,+ // When true, skip the npm prerequisite check. Used by the Electron desktop+ // launcher where npm is not needed at runtime in static mode.+ skipNpmCheck = false,+ // How long to wait for the agent-server's `/server_info` to return 200+ // before continuing. Defaults to 60 s, which is fine for warm-cache dev+ // workflows. The Electron desktop launcher bumps this to several minutes+ // because first-launch on a fresh machine runs `uvx` to download Python+ // and install `openhands-agent-server` from PyPI, which can take much+ // longer than 60 s on a slow network.+ agentServerReadyTimeoutMs = 60_000,+ // Optional `(name, line, level)` callback that receives every service log+ // line (stdout, stderr, and lifecycle events) emitted by any spawned+ // backend process. Used by the Electron loading screen to surface uvx+ // download / install progress to the user. `level` is one of+ // "stdout" | "stderr" | "info" | "warn" | "error".+ onServiceLog,} = options;+ // Install the listener early so log lines emitted before the first+ // `spawnService` call (e.g. by future setup steps) are also captured.+ setServiceLogListener(onServiceLog);+const args = parseArgs();// Allow options to override CLI args for public mode@@ -1239,9 +1285,13 @@ async function main(options = {}) {checkUvx: !args.frontendOnly,// Static-mode + backend-only has no frontend to build, so npm is not// required β unless the caller provides a custom buildStaticFrontend hook.+ // The Electron desktop launcher passes `skipNpmCheck: true` because the+ // packaged binary serves a pre-built static frontend and never invokes+ // npm at runtime, so we suppress the check unconditionally there.checkNpm:- (!useStaticMode && !args.backendOnly) ||- typeof buildStaticFrontend === "function",+ !skipNpmCheck &&+ ((!useStaticMode && !args.backendOnly) ||+ typeof buildStaticFrontend === "function"),checkFrontendDependencies:(!useStaticMode && !args.backendOnly) ||typeof buildStaticFrontend === "function",@@ -1303,16 +1353,23 @@ async function main(options = {}) {let agentServerReady = false;- // 1. Start agent-server first (automation depends on it)+ // 1. Start agent-server first (automation depends on it).+ //+ // Readiness timeout defaults to 60 s, which is fine for `npm run dev` against+ // a warm uvx cache. The Electron desktop launcher overrides this via the+ // `agentServerReadyTimeoutMs` option because first-launch on a fresh machine+ // runs `uvx` to download Python + install `openhands-agent-server` from PyPI,+ // which can take several minutes. Dropping the user into a half-booted UI+ // before that completes triggers axios "Request timeout" popups on the first+ // SPA fetch that hits an unbound port 18000.if (config.launchAgentServer) {const agentServerStarter = startAgentServerOverride ?? startAgentServer;agentServerStarter(config);- // Wait for agent-server to be ready (60s timeout for slow systems)agentServerReady = await waitForService("agent-server",`http://localhost:${config.agentServerPort}/server_info`,- 60000, // 60 second timeout for initial startup+ agentServerReadyTimeoutMs,);}@@ -1353,6 +1410,11 @@ async function main(options = {}) {await delay(1000);printBanner(config);++ // Return the resolved config + readiness signal so embedded launchers can+ // (a) build URLs from the actual allocated ports and (b) decide whether to+ // show an error to the user when the agent-server never came up.+ return { config, agentServerReady };}function startStaticFrontend(config, staticDir) {diff --git a/scripts/download-node.mjs b/scripts/download-node.mjsnew file mode 100644index 0000000000..6826ef602b--- /dev/null+++ b/scripts/download-node.mjs@@ -0,0 +1,382 @@+#!/usr/bin/env node+/**+ * Download the official Node.js distribution for the current platform into+ * resources/node/, so electron-builder can bundle it as an extraResource.+ *+ * The packaged Electron desktop app uses this bundled Node to provide+ * `node`, `npm`, and `npx` to spawned subprocesses β most importantly the+ * stdio MCP servers in the marketplace (Slack, GitHub, Figma, etc.) whose+ * commands start with `npx -y <package>`.+ *+ * Why bundle Node instead of using Electron-as-Node (ELECTRON_RUN_AS_NODE=1)?+ *+ * We tried that first. Electron-as-Node works fine for our backend+ * helper scripts (static-server.mjs, ingress.mjs) which mostly do+ * networking, but it is **not** reliable for stdio JSON-RPC servers.+ * When npx-cli.js (running under Electron-as-Node) spawned the MCP+ * server, the child's stdin pipe semantics differed from vanilla Node+ * on macOS (the parent is a windowed Electron process, not a clean+ * command-line Node binary) β the server appeared to start, then+ * immediately exited with "McpError: Connection closed" before the+ * first JSON-RPC handshake message could land. Bundling the real+ * Node binary sidesteps all of that.+ *+ * The downloaded Node.js distribution already includes npm and npx at+ * `bin/npm` / `bin/npx` (POSIX) or `npm.cmd` / `npx.cmd` (Windows), so we+ * do **not** need a separate npm download (this script supersedes the+ * earlier download-npm.mjs).+ *+ * Usage:+ * node scripts/download-node.mjs # uses NODE_BUNDLE_VERSION below+ * NODE_VERSION=22.10.0 node scripts/download-node.mjs+ *+ * Output (per platform):+ * POSIX: resources/node/bin/{node,npm,npx} + resources/node/lib/node_modules/npm/...+ * Windows: resources/node/{node.exe,npm.cmd,npx.cmd} + resources/node/node_modules/npm/...+ */++import {+ chmodSync,+ createWriteStream,+ existsSync,+ lstatSync,+ mkdirSync,+ readdirSync,+ readlinkSync,+ rmSync,+ statSync,+ unlinkSync,+} from "node:fs";+import { get } from "node:https";+import { tmpdir } from "node:os";+import { dirname, join } from "node:path";+import { fileURLToPath } from "node:url";+import { execFileSync } from "node:child_process";++const __dirname = dirname(fileURLToPath(import.meta.url));+const projectRoot = join(__dirname, "..");+const outDir = join(projectRoot, "resources", "node");++// Pinned Node version. Electron 42 ships Node 22, so we bundle a 22.x+// LTS release to match the embedded runtime's ABI/native-module surface.+// We intentionally use 22.12.0 β the repo's own support floor+// (package.json engines.node >=22.12.0, volta 22.12.0) β rather than+// Electron 42.3.2's exact embedded Node patch level: the bundled binary+// runs this repo's launcher scripts, and native modules only need ABI+// parity (NODE_MODULE_VERSION 127, shared by all 22.x builds).+// Override at build time with NODE_VERSION=β¦ (e.g. to test against a+// newer release). Major version >=22 only; engines.node in npm 10.x+// requires ^18.17.0 || >=20.5.0.+const NODE_BUNDLE_VERSION = "22.12.0";++// ββ Platform detection βββββββββββββββββββββββββββββββββββββββββββββββββββββββ++const PLATFORM = process.platform; // 'darwin' | 'linux' | 'win32'+const ARCH = process.arch; // 'x64' | 'arm64' | 'ia32'++/**+ * Map (platform, arch) β Node's published distribution name.+ * Names come straight from https://nodejs.org/dist/<version>/.+ *+ * macOS arm64 β node-v<ver>-darwin-arm64.tar.gz+ * macOS x64 β node-v<ver>-darwin-x64.tar.gz+ * linux x64 β node-v<ver>-linux-x64.tar.gz+ * linux arm64 β node-v<ver>-linux-arm64.tar.gz+ * win32 x64 β node-v<ver>-win-x64.zip+ * win32 arm64 β node-v<ver>-win-arm64.zip+ */+function getPlatformSpec(version) {+ const base = `node-v${version}`;+ if (PLATFORM === "darwin") {+ const arch = ARCH === "arm64" ? "arm64" : "x64";+ return { name: `${base}-darwin-${arch}`, ext: "tar.gz" };+ }+ if (PLATFORM === "linux") {+ const arch = ARCH === "arm64" ? "arm64" : "x64";+ return { name: `${base}-linux-${arch}`, ext: "tar.gz" };+ }+ if (PLATFORM === "win32") {+ const arch = ARCH === "arm64" ? "arm64" : "x64";+ return { name: `${base}-win-${arch}`, ext: "zip" };+ }+ throw new Error(`Unsupported platform for Node download: ${PLATFORM}/${ARCH}`);+}++// ββ Version resolution βββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function resolveVersion() {+ const requested = process.env.NODE_VERSION?.replace(/^v/, "");+ return requested || NODE_BUNDLE_VERSION;+}++// ββ HTTP helpers βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function downloadFile(url, dest) {+ return new Promise((resolve, reject) => {+ const file = createWriteStream(dest);+ function doGet(u) {+ get(u, { headers: { "User-Agent": "agent-canvas-build" } }, (res) => {+ if (res.statusCode === 301 || res.statusCode === 302) {+ return doGet(res.headers.location);+ }+ if (res.statusCode !== 200) {+ file.destroy();+ return reject(new Error(`GET ${u} β HTTP ${res.statusCode}`));+ }+ res.pipe(file);+ file.on("finish", () => file.close(resolve));+ file.on("error", reject);+ res.on("error", reject);+ }).on("error", (err) => {+ file.destroy();+ reject(err);+ });+ }+ doGet(url);+ });+}++// ββ Extraction βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function extract(archivePath, targetDir, ext) {+ // Both tar.gz and zip extract via system `tar`:+ // GNU/BSD tar (macOS/Linux) handles .tar.gz natively.+ // bsdtar (Windows 10+) handles both .tar.gz and .zip.+ // --strip-components=1 drops the "node-vX.Y.Z-<platform>-<arch>/" top dir.+ void ext; // archive content is identified by tar's own magic bytes+ execFileSync(+ "tar",+ ["-xf", archivePath, "-C", targetDir, "--strip-components=1"],+ { stdio: "inherit" },+ );+}++function ensureExecutable(p) {+ if (process.platform === "win32") return;+ try {+ chmodSync(p, 0o755);+ } catch {}+}++// ββ Layout verification ββββββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Confirm the extracted tree has the binaries we depend on.+ * On Unix Node puts them in bin/; on Windows they live at the root.+ */+function verifyLayout() {+ const isWin = PLATFORM === "win32";+ const required = isWin+ ? ["node.exe", "npm.cmd", "npx.cmd"]+ : ["bin/node", "bin/npm", "bin/npx"];+ for (const rel of required) {+ const p = join(outDir, rel);+ if (!existsSync(p)) {+ throw new Error(+ `Expected ${rel} in extracted Node distribution but it is missing ` ++ `at ${p}. Did the tarball layout change?`,+ );+ }+ ensureExecutable(p);+ }++ // npm/npx are wrapper scripts that invoke node against npm's JS entry+ // points; verify the targets exist too so a packaged build doesn't ship+ // a half-broken installation.+ const npmCli = isWin+ ? join(outDir, "node_modules", "npm", "bin", "npm-cli.js")+ : join(outDir, "lib", "node_modules", "npm", "bin", "npm-cli.js");+ if (!existsSync(npmCli)) {+ throw new Error(`Bundled Node is missing npm-cli.js at ${npmCli}`);+ }+}++// ββ Pruning ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Drop pieces of the Node distribution that are only useful when building+ * native modules from source or for human-readable documentation. Stripping+ * these shrinks the bundled Node from ~170 MB β ~115 MB on Linux x64 (the+ * Node binary itself is the bulk of what remains and can't be reduced).+ *+ * Kept intentionally:+ * bin/node, bin/npm, bin/npx β runtime binaries / wrappers+ * lib/node_modules/{npm,corepack} β npm itself+ * LICENSE β required by the BSD-style Node license+ */+function pruneUnusedFiles() {+ // IMPORTANT: every entry that points into a directory we delete must also+ // delete any symlink/shim that targets into it, otherwise electron-builder+ // hits ENOENT trying to stat() the dangling symlink while copying the+ // extraResource into the .app bundle.+ //+ // Example: Node's POSIX tarball ships `bin/corepack` as a symlink to+ // `../lib/node_modules/corepack/dist/corepack.js`. If we drop the corepack+ // module under lib/ but leave the symlink, `electron-builder` fails with+ // ENOENT: ... Resources/node/bin/corepack+ const candidates =+ PLATFORM === "win32"+ ? [+ // Windows Node zip lays out npm directly under node_modules/, not lib/.+ // Strip docs, headers, and node_modules/corepack (the npm runtime+ // doesn't need corepack to run, and we don't ship yarn/pnpm).+ "CHANGELOG.md",+ "README.md",+ "node_modules/corepack",+ // Windows ships corepack as both a Bash wrapper and a cmd.exe wrapper+ // at the distribution root; both proxy into node_modules/corepack.+ "corepack",+ "corepack.cmd",+ ]+ : [+ // POSIX layout β keep bin/ and lib/node_modules/npm; drop the rest.+ "include",+ "share",+ "CHANGELOG.md",+ "README.md",+ "lib/node_modules/corepack",+ // Symlink in bin/ targets the corepack we just deleted.+ "bin/corepack",+ ];+ for (const rel of candidates) {+ const p = join(outDir, rel);+ // `rmSync(force: true)` resolves the path through symlinks, so once the+ // corepack target directory is deleted the now-dangling `bin/corepack`+ // link reads as "already gone" and silently survives β the exact ENOENT+ // trap failOnDanglingSymlinks() exists to catch. Remove files/symlinks+ // with `unlinkSync` (lstat semantics, works on dangling links) first and+ // fall back to `rmSync` for directories.+ try {+ unlinkSync(p);+ } catch {+ try {+ rmSync(p, { recursive: true, force: true });+ } catch {+ // best-effort+ }+ }+ }+}++// ββ Dangling-symlink check βββββββββββββββββββββββββββββββββββββββββββββββββββ++/**+ * Walk the pruned tree and refuse to finish if any symlink points at a path+ * that no longer exists. electron-builder calls `stat()` (which follows+ * symlinks) on every entry it copies into the .app bundle, so a single+ * dangling symlink blows up the whole `build:desktop` step with a confusing+ * ENOENT β fail at download time instead, with a message that says which+ * pruned directory the symlink was reaching into.+ */+function failOnDanglingSymlinks() {+ const broken = [];+ const stack = [outDir];+ while (stack.length) {+ const next = stack.pop();+ let entries;+ try {+ entries = readdirSync(next, { withFileTypes: true });+ } catch {+ continue;+ }+ for (const entry of entries) {+ const p = join(next, entry.name);+ if (entry.isSymbolicLink()) {+ try {+ // statSync follows the link; if the target is gone this throws.+ statSync(p);+ } catch {+ let target = "<unreadable>";+ try {+ if (lstatSync(p).isSymbolicLink()) target = readlinkSync(p);+ } catch {+ // ignore β best-effort labelling+ }+ broken.push(`${p} β ${target}`);+ }+ } else if (entry.isDirectory()) {+ stack.push(p);+ }+ }+ }+ if (broken.length) {+ console.error(+ "[download-node] Dangling symlinks remain after pruning β these would " ++ "crash electron-builder later with ENOENT. Add the dangling symlink " ++ "(or its target) to pruneUnusedFiles() in this script:",+ );+ for (const entry of broken) console.error(" β’", entry);+ throw new Error(`${broken.length} dangling symlink(s) in resources/node/`);+ }+}++// ββ Size report ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function dirSizeBytes(dir) {+ let total = 0;+ const stack = [dir];+ while (stack.length) {+ const next = stack.pop();+ let entries;+ try {+ entries = readdirSync(next, { withFileTypes: true });+ } catch {+ continue;+ }+ for (const entry of entries) {+ const p = join(next, entry.name);+ if (entry.isDirectory()) {+ stack.push(p);+ } else {+ try {+ total += statSync(p).size;+ } catch {}+ }+ }+ }+ return total;+}++// ββ Main βββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++async function main() {+ const version = resolveVersion();+ const spec = getPlatformSpec(version);+ const archiveName = `${spec.name}.${spec.ext}`;+ const url = `https://nodejs.org/dist/v${version}/${archiveName}`;+ const tmpFile = join(tmpdir(), `node-download-${Date.now()}.${spec.ext}`);++ console.log(+ `[download-node] Downloading Node v${version} for ${PLATFORM}/${ARCH}`,+ );+ console.log(`[download-node] URL: ${url}`);++ try {+ // Clear any previous output so stale files (different Node version, or+ // a stale resources/npm/ from the previous wrapper approach) don't+ // linger in the bundle.+ if (existsSync(outDir)) rmSync(outDir, { recursive: true, force: true });+ mkdirSync(outDir, { recursive: true });++ console.log(`[download-node] Downloading to ${tmpFile}`);+ await downloadFile(url, tmpFile);+ console.log(`[download-node] Extracting to ${outDir}`);+ extract(tmpFile, outDir, spec.ext);++ verifyLayout();+ pruneUnusedFiles();+ failOnDanglingSymlinks();++ const mb = Math.round(dirSizeBytes(outDir) / (1024 * 1024));+ console.log(`[download-node] β Node v${version} ready at ${outDir} (~${mb} MB)`);+ } finally {+ try {+ rmSync(tmpFile, { force: true });+ } catch {}+ }+}++main().catch((err) => {+ console.error("[download-node] Error:", err.message);+ process.exit(1);+});diff --git a/scripts/download-uv.mjs b/scripts/download-uv.mjsnew file mode 100644index 0000000000..818c5dd8d2--- /dev/null+++ b/scripts/download-uv.mjs@@ -0,0 +1,202 @@+#!/usr/bin/env node+/**+ * Download the uv binary for the current platform into resources/bin/+ * so that electron-builder can bundle it as an extraResource.+ *+ * uv provides uvx, which the Electron desktop app uses to run the+ * agent-server and automation backend Python packages.+ *+ * Usage:+ * node scripts/download-uv.mjs # uses latest GitHub release+ * UV_VERSION=0.7.0 node scripts/download-uv.mjs+ *+ * Output (per platform):+ * resources/bin/uv + resources/bin/uvx (macOS / Linux)+ * resources/bin/uv.exe + resources/bin/uvx.exe (Windows)+ */++import {+ chmodSync,+ copyFileSync,+ createWriteStream,+ existsSync,+ mkdirSync,+ rmSync,+} from "node:fs";+import { get } from "node:https";+import { tmpdir } from "node:os";+import { dirname, join } from "node:path";+import { fileURLToPath } from "node:url";+import { execFileSync } from "node:child_process";++const __dirname = dirname(fileURLToPath(import.meta.url));+const projectRoot = join(__dirname, "..");+const outDir = join(projectRoot, "resources", "bin");++// ββ Platform detection βββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++const PLATFORM = process.platform; // 'darwin' | 'linux' | 'win32'+const ARCH = process.arch; // 'x64' | 'arm64'++function getPlatformSpec() {+ if (PLATFORM === "darwin") {+ const uvArch = ARCH === "arm64" ? "aarch64" : "x86_64";+ return {+ target: `uv-${uvArch}-apple-darwin`,+ ext: "tar.gz",+ binaries: ["uv", "uvx"],+ };+ }+ if (PLATFORM === "linux") {+ // Only x64 is officially supported by uv for desktop builds+ return {+ target: "uv-x86_64-unknown-linux-gnu",+ ext: "tar.gz",+ binaries: ["uv", "uvx"],+ };+ }+ if (PLATFORM === "win32") {+ return {+ target: "uv-x86_64-pc-windows-msvc",+ ext: "zip",+ binaries: ["uv.exe", "uvx.exe"],+ };+ }+ throw new Error(`Unsupported platform for uv download: ${PLATFORM}`);+}++// ββ Version resolution ββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++async function resolveVersion() {+ if (process.env.UV_VERSION) {+ return process.env.UV_VERSION.replace(/^v/, "");+ }++ console.log("[download-uv] Fetching latest uv version from GitHub API...");+ const data = await fetchJson(+ "https://api.github.com/repos/astral-sh/uv/releases/latest",+ { "User-Agent": "agent-canvas-build" }+ );+ const version = data.tag_name?.replace(/^v/, "");+ if (!version) throw new Error("Could not parse uv version from GitHub API");+ return version;+}++// ββ HTTP helpers ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function fetchJson(url, headers = {}) {+ return new Promise((resolve, reject) => {+ get(url, { headers }, (res) => {+ if (res.statusCode === 301 || res.statusCode === 302) {+ return resolve(fetchJson(res.headers.location, headers));+ }+ if (res.statusCode !== 200) {+ return reject(new Error(`GET ${url} β HTTP ${res.statusCode}`));+ }+ let body = "";+ res.on("data", (chunk) => (body += chunk));+ res.on("end", () => resolve(JSON.parse(body)));+ res.on("error", reject);+ }).on("error", reject);+ });+}++function downloadFile(url, dest) {+ return new Promise((resolve, reject) => {+ const file = createWriteStream(dest);+ function doGet(u) {+ get(u, { headers: { "User-Agent": "agent-canvas-build" } }, (res) => {+ if (res.statusCode === 301 || res.statusCode === 302) {+ return doGet(res.headers.location);+ }+ if (res.statusCode !== 200) {+ file.destroy();+ return reject(new Error(`GET ${u} β HTTP ${res.statusCode}`));+ }+ res.pipe(file);+ file.on("finish", () => file.close(resolve));+ file.on("error", reject);+ res.on("error", reject);+ }).on("error", (err) => {+ file.destroy();+ reject(err);+ });+ }+ doGet(url);+ });+}++// ββ Extraction ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++function extract(archivePath, targetDir, ext) {+ // Both tar.gz and zip are handled by the system 'tar' command:+ // macOS/Linux: GNU/BSD tar natively supports .tar.gz+ // Windows 10+: built-in bsdtar supports both .tar.gz and .zip+ // --strip-components=1 removes the top-level archive directory so+ // uv/uvx end up directly in targetDir.+ execFileSync(+ "tar",+ [+ "-xf",+ archivePath,+ "-C",+ targetDir,+ "--strip-components=1",+ ],+ { stdio: "inherit" }+ );+}++// ββ Main ββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββββ++async function main() {+ const spec = getPlatformSpec();+ const version = await resolveVersion();++ console.log(`[download-uv] Downloading uv v${version} for ${PLATFORM}/${ARCH}`);++ const filename = `${spec.target}.${spec.ext}`;+ const url = `https://github.com/astral-sh/uv/releases/download/${version}/${filename}`;+ const tmpFile = join(tmpdir(), `uv-download-${Date.now()}.${spec.ext}`);+ const extractDir = join(tmpdir(), `uv-extract-${Date.now()}`);++ try {+ mkdirSync(outDir, { recursive: true });+ mkdirSync(extractDir, { recursive: true });++ console.log(`[download-uv] URL: ${url}`);+ await downloadFile(url, tmpFile);+ console.log(`[download-uv] Extracting to ${outDir}...`);+ extract(tmpFile, extractDir, spec.ext);++ // Copy the required binaries to outDir+ for (const bin of spec.binaries) {+ const src = join(extractDir, bin);+ const dest = join(outDir, bin);++ if (!existsSync(src)) {+ throw new Error(`Expected binary not found after extraction: ${src}`);+ }++ // copyFileSync works across filesystems (unlike renameSync with EXDEV)+ copyFileSync(src, dest);++ if (process.platform !== "win32") {+ chmodSync(dest, 0o755);+ }++ console.log(`[download-uv] β ${dest}`);+ }++ console.log("[download-uv] Done. Binaries are ready for bundling.");+ } finally {+ // Clean up temp files (best-effort)+ try { rmSync(tmpFile, { force: true }); } catch {}+ try { rmSync(extractDir, { recursive: true, force: true }); } catch {}+ }+}++main().catch((err) => {+ console.error("[download-uv] Error:", err.message);+ process.exit(1);+});diff --git a/scripts/logger.mjs b/scripts/logger.mjsindex 9c93bdd64a..3710952f1a 100644--- a/scripts/logger.mjs+++ b/scripts/logger.mjs@@ -1,19 +1,21 @@/*** Shared file logger for agent-canvas dev scripts.*- * Writes log output to a daily-rotating file under <project-root>/logs/- * alongside the existing console output (which is unchanged).+ * Writes log output to a daily-rotating file under+ * <state-dir>/logs/agent-canvas.YYYY-MM-DD.log (7-day retention) alongside+ * the existing console output (which is unchanged).*- * File naming: logs/agent-canvas.YYYY-MM-DD.log- * Retention: 7 days (files older than 7 days are automatically deleted)+ * winston is loaded dynamically and treated as optional: when it isn't+ * resolvable β most importantly inside the packaged Electron desktop app,+ * whose `afterPack` hook strips `Resources/app/node_modules/` β `fileLog`+ * becomes a no-op and console logging continues to work unchanged. See+ * AGENTS.md "Electron desktop packaging" for the strip-hook details.*/import { mkdirSync } from "node:fs";import { homedir } from "node:os";import { join } from "node:path";import process from "node:process";-import { createLogger, format } from "winston";-import DailyRotateFile from "winston-daily-rotate-file";// Mirror the state-directory logic from dev-safe.mjs so log files live// alongside all other agent-canvas runtime state (e.g. ~/.openhands/agent-canvas).@@ -23,9 +25,6 @@ const stateDir =join(homedir(), ".openhands", "agent-canvas");const logDir = join(stateDir, "logs");-// Ensure the logs directory exists before the transport tries to open a file.-mkdirSync(logDir, { recursive: true });-// Matches any ANSI CSI escape sequence (colors, cursor movement, etc.).const ANSI_RE = /\x1b\[[0-9;]*m/g;@@ -38,40 +37,70 @@ export function stripAnsi(str) {return typeof str === "string" ? str.replace(ANSI_RE, "") : String(str);}-const fileTransport = new DailyRotateFile({- dirname: logDir,- filename: "agent-canvas.%DATE%.log",- datePattern: "YYYY-MM-DD",- maxFiles: "7d",- // Audit file tracks which rotated files exist; kept alongside log files.- auditFile: join(logDir, ".log-audit.json"),- createSymlink: false,-});+/**+ * Attempt to construct a winston-backed file logger. Returns `null` if+ * winston isn't installed (packaged desktop app) or any setup step fails;+ * `fileLog` then degrades to a no-op.+ *+ * @returns {Promise<import("winston").Logger | null>}+ */+async function createFileLogger() {+ let winston;+ let DailyRotateFileMod;+ try {+ winston = await import("winston");+ DailyRotateFileMod = await import("winston-daily-rotate-file");+ } catch {+ return null;+ }++ try {+ mkdirSync(logDir, { recursive: true });++ const DailyRotateFile =+ DailyRotateFileMod.default ?? DailyRotateFileMod;+ const fileTransport = new DailyRotateFile({+ dirname: logDir,+ filename: "agent-canvas.%DATE%.log",+ datePattern: "YYYY-MM-DD",+ maxFiles: "7d",+ auditFile: join(logDir, ".log-audit.json"),+ createSymlink: false,+ });-const fileLogger = createLogger({- level: "debug",- format: format.combine(- format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),- format.printf(- ({ timestamp, level, message }) =>- `${timestamp} [${level.toUpperCase().padEnd(5)}] ${message}`,- ),- ),- transports: [fileTransport],-});+ const logger = winston.createLogger({+ level: "debug",+ format: winston.format.combine(+ winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss" }),+ winston.format.printf(+ ({ timestamp, level, message }) =>+ `${timestamp} [${level.toUpperCase().padEnd(5)}] ${message}`,+ ),+ ),+ transports: [fileTransport],+ });++ // Swallow any transport-level errors (e.g. disk full) so a logging+ // failure never crashes the dev server.+ logger.on("error", () => {});+ fileTransport.on("error", () => {});+ return logger;+ } catch {+ return null;+ }+}-// Swallow any transport-level errors (e.g. disk full) so a logging failure-// never crashes the dev server.-fileLogger.on("error", () => {});-fileTransport.on("error", () => {});+const fileLogger = await createFileLogger();/**- * Write a message to the rotating log file.- * ANSI escape codes are stripped automatically; console output is unaffected.+ * Write a message to the rotating log file. No-ops when winston isn't+ * available (e.g. the packaged desktop app). ANSI escape codes are+ * stripped automatically; console output is unaffected.** @param {'info' | 'warn' | 'error' | 'debug'} level* @param {string} message*/export function fileLog(level, message) {+ if (!fileLogger) return;fileLogger.log(level, stripAnsi(message));}diff --git a/src/api/conversation-service/agent-server-conversation-service.api.ts b/src/api/conversation-service/agent-server-conversation-service.api.tsindex fe7d6c991a..633b37758c 100644--- a/src/api/conversation-service/agent-server-conversation-service.api.ts+++ b/src/api/conversation-service/agent-server-conversation-service.api.ts@@ -70,6 +70,10 @@ import type {} from "./agent-server-conversation-service.types";const DEFAULT_CONVERSATION_TIMESTAMP = "1970-01-01T00:00:00.000Z";+// Creating the first conversation right after a cold agent-server boot (fresh+// machine or the packaged desktop app, where uvx may still be warming caches)+// can exceed the client's 60s default timeout.+const CREATE_CONVERSATION_TIMEOUT_MS = 5 * 60 * 1000;const INVALID_CONVERSATION_RESPONSE_MESSAGE ="Unable to load conversations because the selected agent server returned " +"data this UI does not understand. Check the backend URL/session key and " +@@ -434,7 +438,7 @@ class AgentServerConversationService {});const data = await new ConversationClient(- getAgentServerClientOptions(),+ getAgentServerClientOptions({ timeout: CREATE_CONVERSATION_TIMEOUT_MS }),).createConversation<DirectConversationInfo>(payload);const localBackend = getEffectiveLocalBackend();if (!localBackend) throw new NoBackendAvailableError();