akanjs 3.0.0-beta.2 → 3.0.0-beta.21

package/vendor/@akanjs/native/plugins/updates/src/desktop.ts

@@ -0,0 +1,558 @@
+
+
+import { spawn } from "node:child_process";
+import { createHash, createPublicKey, verify } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { AkanNativeError } from "../../../packages/core/src/index.ts";
+import { isBundleId } from "../../../packages/core/src/kernel.ts";
+import { applyDelta } from "../../../packages/desktop/src/delta.ts";
+import { type DesktopContext, type DesktopPlugin, defineDesktopPlugin } from "../../../packages/desktop/src/plugin.ts";
+import type { UpdateCheck, UpdateState, UpdatesApi, UpdatesEvents } from "./index.ts";
+
+interface Config {
+  app: string;
+  platform: string;
+  nativeApi: string | null;
+  embeddedSequence: number;
+  url: string;
+  publicKey: string;
+  channel: string;
+  readyTimeout: number;
+}
+
+interface Entry {
+  bundle: string;
+  sequence: number;
+  version: string;
+  /** sha256 of the release tar (the base of the next delta). */
+  tar: string;
+  /** embeddedSequence of that release's app: tells whether the running app is it. */
+  build: number;
+}
+
+interface State {
+  current?: Entry;
+  pending?: Entry & { staged: string };
+  /** `pid`: the process running the trial, so a second instance of the app leaves it alone. */
+  trial?: Entry & { previous: string; attempts: number; pid?: number };
+  failed: string[];
+  rolledBack?: string;
+}
+
+interface Manifest {
+  schema: number;
+  kind: string;
+  app: string;
+  platform: string;
+  channel: string;
+  sequence: number;
+  bundle: string;
+  version: string;
+  build?: number;
+  arch?: string;
+  archive?: { sha256: string; url: string; size: number; gzSha256: string };
+  patches?: { from: string; url: string; sha256: string; size: number }[];
+}
+
+const MAX_MANIFEST = 1 << 20;
+const MAX_SIGNATURE = 1024;
+const sha256 = (data: Uint8Array) => createHash("sha256").update(data).digest("hex");
+
+/** Whether a process exists (signal 0 only checks; EPERM means it exists but is not ours). */
+function alive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as { code?: string }).code === "EPERM";
+  }
+}
+
+const mac = process.platform === "darwin";
+const windows = process.platform === "win32";
+
+/**
+ * The running app, from the executable path: macOS <App>.app/Contents/MacOS/<exe>, Windows and
+ * Linux the folder of <exe> with resources/ (packages/desktop/src/ffi.ts resolvePaths).
+ */
+function appPath(): string | null {
+  const exeDir = dirname(process.execPath);
+  if (!mac) return existsSync(join(exeDir, "resources", "boot.json")) ? exeDir : null;
+  const app = dirname(dirname(exeDir));
+  return basename(exeDir) === "MacOS" && app.endsWith(".app") ? app : null;
+}
+
+const resourcesOf = (app: string) => (mac ? join(app, "Contents", "Resources") : join(app, "resources"));
+/** The executable inside an app with the running one's name. */
+const executableIn = (app: string) =>
+  mac ? join(app, "Contents", "MacOS", basename(process.execPath)) : join(app, basename(process.execPath));
+
+function readConfig(): Config | null {
+  const app = appPath();
+  const path = app ? join(resourcesOf(app), "updates.json") : "";
+  if (!app || !existsSync(path)) return null;
+  const c = JSON.parse(readFileSync(path, "utf8")) as Config;
+  return typeof c.url === "string" && typeof c.publicKey === "string" ? c : null;
+}
+
+export default defineDesktopPlugin<UpdatesApi, UpdatesEvents>(
+  (() => {
+    const config = readConfig();
+    let dir = "";
+    let onTrial = false;
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    let downloading = false;
+
+    const statePath = () => join(dir, "state.json");
+    const readState = (): State => {
+      try {
+        const s = JSON.parse(readFileSync(statePath(), "utf8")) as State;
+        return { ...s, failed: Array.isArray(s.failed) ? s.failed : [] };
+      } catch {
+        return { failed: [] };
+      }
+    };
+    const writeState = (state: State) => {
+      mkdirSync(dir, { recursive: true });
+      const tmp = `${statePath()}.tmp`;
+      writeFileSync(tmp, JSON.stringify({ ...state, failed: state.failed.slice(-20) }));
+      renameSync(tmp, statePath());
+    };
+    const need = (): Config => {
+      if (!config)
+        throw new AkanNativeError(
+          "UNSUPPORTED",
+          "updates are not configured (akan-native.config.ts `updates`, a built app)",
+        );
+      return config;
+    };
+    /** The running app is this release (installed by an update), not another build. */
+    const runningIs = (entry: Entry | undefined) => !!entry && !!config && entry.build === config.embeddedSequence;
+
+    /**
+     * Once this process has exited (single-instance, locks): renames `moves` in order and starts
+     * `app` with this environment. macOS and Linux rename a running app's folder right away, so only
+     * the start waits; Windows refuses that, so a helper does the renames too (and on a failed
+     * rename puts back what it moved, so there is always an app to start).
+     */
+    const moveThenRelaunch = (moves: [string, string][], app: string): Promise<void> => {
+      const exe = executableIn(app);
+      if (!windows) {
+        for (const [from, to] of moves) renameSync(from, to);
+        const child = spawn(
+          "/bin/sh",
+          ["-c", 'while kill -0 "$AKAN_NATIVE_PARENT" 2>/dev/null; do sleep 0.2; done; exec "$AKAN_NATIVE_EXE"'],
+          {
+            detached: true,
+            stdio: "inherit",
+            env: { ...process.env, AKAN_NATIVE_PARENT: String(process.pid), AKAN_NATIVE_EXE: exe },
+          },
+        );
+        child.unref();
+        return Promise.resolve();
+      }
+
+      const script = `
+$ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
+Wait-Process -Id $env:AKAN_NATIVE_PARENT -ErrorAction SilentlyContinue
+$moves = $env:AKAN_NATIVE_MOVES | ConvertFrom-Json
+$done = @()
+try {
+  foreach ($m in $moves) {
+    for ($i = 0; ; $i++) { try { Move-Item -LiteralPath $m[0] -Destination $m[1]; break } catch { if ($i -ge 40) { throw }; Start-Sleep -Milliseconds 250 } }
+    $done = ,$m + $done
+  }
+} catch {
+  foreach ($m in $done) { try { Move-Item -LiteralPath $m[1] -Destination $m[0] } catch {} }
+}
+Start-Process -NoNewWindow -FilePath $env:AKAN_NATIVE_EXE
+`;
+
+      const encoded = Buffer.from(script, "utf16le").toString("base64");
+      const env = {
+        ...process.env,
+        AKAN_NATIVE_PARENT: String(process.pid),
+        AKAN_NATIVE_EXE: exe,
+        AKAN_NATIVE_MOVES: JSON.stringify(moves),
+      };
+      const args = [
+        "/d",
+        "/c",
+        "start",
+        "/b",
+        "powershell.exe",
+        "-NoProfile",
+        "-NonInteractive",
+        "-WindowStyle",
+        "Hidden",
+        "-EncodedCommand",
+        encoded,
+      ];
+      let child: ReturnType<typeof spawn>;
+      try {
+        child = spawn("cmd.exe", args, { stdio: "inherit", windowsHide: true, env });
+      } catch {
+        child = spawn("cmd.exe", args, { stdio: "ignore", windowsHide: true, env }); 
+      }
+      return new Promise((resolve) => {
+        const done = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        const timeout = setTimeout(done, 2_500); 
+        child.once("exit", done);
+        child.once("error", (error) => {
+          console.error("[akan-native] updates: cannot start the relaunch helper", error);
+          done();
+        });
+      });
+    };
+
+    /** Puts .previous back, marks the trial failed and relaunches the old app. */
+    const rollBack = async (state: State, quit: (code: number) => void, why: string): Promise<void> => {
+      const trial = state.trial;
+      if (!trial) return; 
+      const app = appPath()!;
+      console.warn(`[akan-native] updates: ${trial.bundle} ${why}; rolling back`);
+      state.trial = undefined;
+      state.failed.push(trial.bundle);
+      state.rolledBack = trial.bundle;
+      if (existsSync(trial.previous)) {
+        const failed = `${app}.failed-${trial.bundle}`;
+        rmSync(failed, { recursive: true, force: true });
+        writeState(state);
+        
+        await moveThenRelaunch(
+          [
+            [app, failed],
+            [trial.previous, app],
+          ],
+          app,
+        );
+        quit(0);
+      } else writeState(state);
+    };
+
+    /**
+     * At most `limit` bytes (the manifest and its signature are read before they are verified, so a
+     * bad server or a changed response could otherwise send anything; a file has its signed size).
+     */
+    const fetchBytes = async (url: string, limit: number, ctx?: DesktopContext): Promise<Uint8Array> => {
+      
+      const response = await fetch(url, { cache: "no-store", ...(ctx?.signal ? { signal: ctx.signal } : {}) });
+      if (response.status === 404) throw new AkanNativeError("NOT_FOUND", `${url} not found`);
+      if (!response.ok) throw new AkanNativeError("INTERNAL", `${url}: HTTP ${response.status}`);
+      const tooBig = () => new AkanNativeError("INTERNAL", `${url} is larger than ${limit} bytes`);
+      if (Number(response.headers.get("content-length") ?? 0) > limit) throw tooBig();
+      const chunks: Uint8Array[] = [];
+      let received = 0;
+      for await (const chunk of response.body ?? []) {
+        chunks.push(chunk);
+        received += chunk.length;
+        if (received > limit) {
+          void response.body?.cancel().catch(() => {});
+          throw tooBig();
+        }
+        ctx?.emit("progress", { received, total: limit });
+      }
+      const out = new Uint8Array(received);
+      let at = 0;
+      for (const c of chunks) out.set(c, at), (at += c.length);
+      return out;
+    };
+
+    const releases = (c: Config) => `${c.url}/${c.platform}-${process.arch}`;
+
+    const fetchRelease = async (c: Config): Promise<Manifest> => {
+      const base = `${releases(c)}/${c.channel}.json`;
+      const manifest = await fetchBytes(base, MAX_MANIFEST);
+      const signature = Buffer.from(
+        new TextDecoder().decode(await fetchBytes(`${base}.sig`, MAX_SIGNATURE)).trim(),
+        "base64",
+      );
+      const spki = Buffer.concat([Buffer.from("302a300506032b6570032100", "hex"), Buffer.from(c.publicKey, "base64")]);
+      if (!verify(null, manifest, createPublicKey({ key: spki, format: "der", type: "spki" }), signature)) {
+        throw new AkanNativeError("INTERNAL", "the release signature does not match updates.publicKey");
+      }
+      const m = JSON.parse(new TextDecoder().decode(manifest)) as Manifest;
+      const hex = (s: unknown) => typeof s === "string" && /^[0-9a-f]{64}$/.test(s);
+      if (
+        m.schema !== 1 ||
+        m.kind !== "app" ||
+        m.app !== c.app ||
+        m.platform !== c.platform ||
+        m.arch !== process.arch ||
+        m.channel !== c.channel
+      ) {
+        throw new AkanNativeError(
+          "INTERNAL",
+          "invalid release manifest: made for another app, platform, CPU or channel",
+        );
+      }
+      if (
+        typeof m.bundle !== "string" ||
+        !isBundleId(m.bundle) ||
+        !(m.sequence > 0) ||
+        typeof m.build !== "number" ||
+        !m.archive ||
+        !hex(m.archive.sha256) ||
+        !hex(m.archive.gzSha256)
+      ) {
+        throw new AkanNativeError("INTERNAL", "invalid release manifest");
+      }
+      return m;
+    };
+
+    const running = (state: State) => (runningIs(state.current) ? state.current!.sequence : config!.embeddedSequence);
+    const isNewer = (m: Manifest, state: State) => m.sequence > running(state) && !state.failed.includes(m.bundle);
+    const patchFor = (m: Manifest, state: State) => {
+      const tar = runningIs(state.current) ? state.current!.tar : undefined;
+      return tar && existsSync(join(dir, "app", `${tar}.tar`)) ? m.patches?.find((p) => p.from === tar) : undefined;
+    };
+
+    const setup = (ctx: DesktopContext) => {
+      dir = join(ctx.appDataDir, "akan-native-updates");
+      const app = appPath();
+      if (!config || !app) return;
+      
+      const state = readState();
+      for (const name of readdirSync(dirname(app))) {
+        const path = join(dirname(app), name);
+        if (
+          name.startsWith(`${basename(app)}.failed-`) ||
+          (name.startsWith(`${basename(app)}.update-`) && path !== dirname(state.pending?.staged ?? ""))
+        ) {
+          rmSync(path, { recursive: true, force: true });
+        }
+      }
+      if (state.trial) {
+        if (!runningIs(state.trial)) {
+          state.trial = undefined; 
+          writeState(state);
+        } else if (state.trial.pid !== undefined && state.trial.pid !== process.pid && alive(state.trial.pid)) {
+        } else if (++state.trial.attempts > 1) {
+          return rollBack(state, (code) => ctx.launch.exit(code), "was started again without notifyReady()");
+        } else {
+          state.trial.pid = process.pid;
+          writeState(state);
+          onTrial = true;
+          ctx.onNativeEvent("pageLoad", (e) => {
+            if (e.event !== "finished" || (e.window ?? 1) !== 1 || !onTrial) return;
+            clearTimeout(timer);
+            timer = setTimeout(() => {
+              if (onTrial) void rollBack(readState(), (code) => ctx.quit(code), "did not call notifyReady() in time");
+            }, config.readyTimeout);
+          });
+        }
+      }
+    };
+
+    const plugin: DesktopPlugin<UpdatesApi, UpdatesEvents> = {
+      id: "updates",
+      setup,
+      
+      events: { progress: () => () => {} },
+      methods: {
+        async getState() {
+          const c = need();
+          const state = readState();
+          const current = runningIs(state.trial) ? state.trial : runningIs(state.current) ? state.current : undefined;
+          return {
+            bundle: current?.bundle ?? null,
+            sequence: current?.sequence ?? 0,
+            pending: state.pending?.bundle ?? null,
+            trial: onTrial,
+            rolledBack: state.rolledBack ?? null,
+            channel: c.channel,
+            nativeApi: c.nativeApi,
+          } satisfies UpdateState;
+        },
+
+        async check() {
+          const c = need();
+          const m = await fetchRelease(c);
+          const state = readState();
+          const available = isNewer(m, state);
+          return {
+            available,
+            bundle: m.bundle,
+            version: m.version,
+            sequence: m.sequence,
+            downloadSize: available ? (patchFor(m, state)?.size ?? m.archive!.size) : null,
+          } satisfies UpdateCheck;
+        },
+
+        async download(_args, ctx) {
+          const c = need();
+          const app = appPath()!;
+          if (downloading) throw new AkanNativeError("CANCELLED", "a download is already running");
+          downloading = true;
+          try {
+            const m = await fetchRelease(c);
+            const state = readState();
+            if (!isNewer(m, state)) throw new AkanNativeError("NOT_FOUND", "no newer release for this app");
+            if (state.pending?.bundle === m.bundle && existsSync(state.pending.staged)) return { bundle: m.bundle };
+            
+            let tar: Uint8Array | null = null;
+            const patch = patchFor(m, state);
+            if (patch) {
+              try {
+                const gz = await fetchBytes(`${releases(c)}/${patch.url}`, patch.size, ctx);
+                if (sha256(gz) !== patch.sha256) throw new Error("delta hash");
+                tar = applyDelta(
+                  readFileSync(join(dir, "app", `${patch.from}.tar`)),
+                  Bun.gunzipSync(gz as Uint8Array<ArrayBuffer>),
+                );
+              } catch (error) {
+                console.warn("[akan-native] updates: delta failed, downloading the whole release", error);
+                tar = null;
+              }
+            }
+            if (!tar) {
+              const gz = await fetchBytes(`${releases(c)}/${m.archive!.url}`, m.archive!.size, ctx);
+              if (sha256(gz) !== m.archive!.gzSha256)
+                throw new AkanNativeError("INTERNAL", "the release archive does not match its hash");
+              tar = Bun.gunzipSync(gz as Uint8Array<ArrayBuffer>);
+            }
+            if (sha256(tar) !== m.archive!.sha256)
+              throw new AkanNativeError("INTERNAL", "the release does not match its hash");
+
+            const staging = `${app}.update-${m.bundle}`;
+            rmSync(staging, { recursive: true, force: true });
+            mkdirSync(staging, { recursive: true });
+            const tarFile = join(staging, "release.tar");
+            writeFileSync(tarFile, tar);
+            const run = async (cmd: string[]) => {
+              const p = Bun.spawn(cmd, { stdout: "pipe", stderr: "pipe" });
+              const [err, code] = await Promise.all([new Response(p.stderr).text(), p.exited]);
+              if (code !== 0) throw new AkanNativeError("INTERNAL", `${basename(cmd[0]!)} failed: ${err.trim()}`);
+            };
+            
+            await run([windows ? "tar.exe" : "/usr/bin/tar", "-xf", tarFile, "-C", staging]);
+            rmSync(tarFile);
+            const staged = join(staging, basename(app));
+            if (!existsSync(executableIn(staged)))
+              throw new AkanNativeError(
+                "INTERNAL",
+                `the release has no ${basename(app)} with ${basename(process.execPath)}`,
+              );
+            let id = "";
+            if (mac) {
+              id = Bun.spawnSync([
+                "/usr/bin/plutil",
+                "-extract",
+                "CFBundleIdentifier",
+                "raw",
+                "-o",
+                "-",
+                join(staged, "Contents", "Info.plist"),
+              ])
+                .stdout.toString()
+                .trim();
+            } else {
+              try {
+                id =
+                  (
+                    JSON.parse(readFileSync(join(resourcesOf(staged), "boot.json"), "utf8")) as {
+                      app?: { id?: string };
+                    }
+                  ).app?.id ?? "";
+              } catch {}
+            }
+            if (id !== c.app)
+              throw new AkanNativeError("INTERNAL", `the release is ${id || "not an akan-native app"}, not ${c.app}`);
+
+            if (mac) await run(["/usr/bin/codesign", "--verify", "--deep", "--strict", staged]);
+
+            mkdirSync(join(dir, "app"), { recursive: true });
+            for (const name of readdirSync(join(dir, "app"))) rmSync(join(dir, "app", name), { force: true });
+            writeFileSync(join(dir, "app", `${m.archive!.sha256}.tar`), tar);
+            state.pending = {
+              bundle: m.bundle,
+              sequence: m.sequence,
+              version: m.version,
+              tar: m.archive!.sha256,
+              build: m.build!,
+              staged,
+            };
+            writeState(state);
+            return { bundle: m.bundle };
+          } finally {
+            downloading = false;
+          }
+        },
+
+        async apply(_args, ctx) {
+          need();
+          const app = appPath()!;
+          const state = readState();
+          const pending = state.pending;
+          if (!pending || !existsSync(pending.staged))
+            throw new AkanNativeError("NOT_FOUND", "no downloaded update to apply");
+          const previous = `${app}.previous`;
+          rmSync(previous, { recursive: true, force: true });
+          const { staged: _staged, ...entry } = pending;
+          if (windows) {
+            
+            state.trial = { ...entry, previous, attempts: 0 };
+            state.pending = undefined;
+            writeState(state);
+            await moveThenRelaunch(
+              [
+                [app, previous],
+                [pending.staged, app],
+              ],
+              app,
+            );
+          } else {
+
+            state.trial = { ...entry, previous, attempts: 0 };
+            state.pending = undefined;
+            writeState(state);
+            let moved = false;
+            try {
+              renameSync(app, previous);
+              moved = true;
+              renameSync(pending.staged, app);
+            } catch (error) {
+              if (moved) renameSync(previous, app); 
+              state.trial = undefined;
+              state.pending = pending;
+              writeState(state);
+              throw new AkanNativeError("INTERNAL", `could not move the update into place: ${error}`);
+            }
+            rmSync(dirname(pending.staged), { recursive: true, force: true });
+            await moveThenRelaunch([], app);
+          }
+          setTimeout(() => ctx.quit(0), 50); 
+        },
+
+        async notifyReady() {
+          need();
+          if (!onTrial) return;
+          clearTimeout(timer);
+          onTrial = false;
+          const state = readState();
+          const trial = state.trial;
+          if (!trial) return;
+          const { previous, attempts: _attempts, ...entry } = trial;
+          state.current = entry;
+          state.trial = undefined;
+          state.rolledBack = undefined;
+          writeState(state);
+          rmSync(previous, { recursive: true, force: true });
+        },
+
+        async reset() {
+          need();
+          const state = readState();
+          if (state.pending) rmSync(dirname(state.pending.staged), { recursive: true, force: true });
+          writeState({ failed: [], ...(state.current ? { current: state.current } : {}) });
+        },
+      },
+    };
+    return plugin;
+  })(),
+);

package/vendor/@akanjs/native/plugins/updates/src/index.ts

@@ -0,0 +1,95 @@
+import { createLiveValue, definePlugin, isAkanNativeError } from "../../../packages/core/src/index.ts";
+import { useLiveValue } from "../../../packages/react/src/index.ts";
+
+/**
+ * Over-the-air updates. On iOS and Android they replace the web bundle (UP-2); the native code
+ * stays, so a bundle only runs in a binary with the same native API (UP-3, `nativeApi`). Releases
+ * are made with `akan-native update publish <platform>` and signed with the key of `akan-native update keygen`.
+ *
+ * A new bundle first runs on trial: the app calls notifyReady() once it works. A trial that does
+ * not confirm within `updates.readyTimeout` (akan-native.config.ts, default 10 s), or that crashes and is
+ * launched again, is rolled back to the previous bundle.
+ */
+export interface UpdateState {
+  /** The downloaded bundle running now; null = the one inside the app. */
+  bundle: string | null;
+  /** Its sequence (publish time, seconds); 0 for the app's own bundle. */
+  sequence: number;
+  /** Downloaded and verified, runs at the next launch or after apply(). */
+  pending: string | null;
+  /** Running for the first time: call notifyReady() once the app works, or it is rolled back. */
+  trial: boolean;
+  /** The last bundle that was rolled back, if any. */
+  rolledBack: string | null;
+  /** The manifest channel (akan-native.config.ts `updates.channel`). */
+  channel: string;
+  /** What this binary provides natively (UP-3); bundles for another value are ignored. */
+  nativeApi: string | null;
+}
+
+export interface UpdateCheck {
+  /** A newer bundle for this binary exists (not rolled back before). */
+  available: boolean;
+  bundle: string | null;
+  /** The app version it was published with. */
+  version: string | null;
+  sequence: number | null;
+  /** Bytes still to download; files the running bundle already has are copied. */
+  downloadSize: number | null;
+}
+
+export interface UpdateProgress {
+  received: number;
+  total: number;
+}
+
+export interface UpdatesApi {
+  getState(): Promise<UpdateState>;
+  /** Fetches and verifies the signed manifest. Rejects NOT_FOUND when nothing is published, INTERNAL for a bad signature. */
+  check(): Promise<UpdateCheck>;
+  /** Downloads and verifies the latest bundle; it runs at the next launch (or apply()). */
+  download(): Promise<{ bundle: string }>;
+  /** Reloads the page into the downloaded bundle now (on trial). Rejects NOT_FOUND without one. */
+  apply(): Promise<void>;
+  /** The running bundle works: keep it. Call it once the app has started; harmless otherwise. */
+  notifyReady(): Promise<void>;
+  /** Back to the app's own bundle from the next launch on. */
+  reset(): Promise<void>;
+}
+
+export interface UpdatesEvents {
+  progress: UpdateProgress;
+}
+
+export const updates = definePlugin<UpdatesApi, UpdatesEvents>("updates", {
+  methods: ["getState", "check", "download", "apply", "notifyReady", "reset"],
+  events: ["progress"],
+});
+
+/**
+ * notifyReady() where updates exist, nothing elsewhere (web, apps without updates configured).
+ * Call it once the app has rendered.
+ */
+export async function markReady(): Promise<void> {
+  if (!updates.isSupported("notifyReady")) return;
+  try {
+    await updates.notifyReady();
+  } catch (error) {
+    if (!isAkanNativeError(error, "UNSUPPORTED")) throw error;
+  }
+}
+
+const state = createLiveValue<UpdateState | null>(null, (set) => {
+  if (updates.isSupported("getState")) updates.getState().then(set, () => set(null));
+});
+
+/** The update state, refreshed after download/apply through `refresh()`. null where updates do not exist. */
+export function useUpdateState(): { state: UpdateState | null; refresh: () => Promise<void> } {
+  const value = useLiveValue(state);
+  return {
+    state: value,
+    refresh: async () => {
+      if (updates.isSupported("getState")) state.set(await updates.getState());
+    },
+  };
+}

package/vendor/@akanjs/native/plugins/window/native-plugin.json

@@ -0,0 +1,32 @@
+{
+  "id": "window",
+  "apiVersion": 1,
+  "methods": [
+    "getState",
+    "setTitle",
+    "setSize",
+    "setPosition",
+    "center",
+    "minimize",
+    "maximize",
+    "unmaximize",
+    "restore",
+    "setFullscreen",
+    "setAlwaysOnTop",
+    "show",
+    "hide",
+    "focus",
+    "close",
+    "startDragging",
+    "toggleMaximize",
+    "answerCloseRequested",
+    "create",
+    "list"
+  ],
+  "events": ["resize", "move", "focus", "closeRequested", "created", "destroyed", "dragDrop"],
+  "coalesce": ["resize", "move"],
+  "web": "./src/web.ts",
+  "desktop": "./src/desktop.ts",
+  "ios": null,
+  "android": null
+}