@justin06lee/subaru 0.1.0

package/dist/electron-renderer.d.ts

@@ -0,0 +1,34 @@
+import { U as UpdaterState, a as UpdaterLike } from './core-DmEjLKLp.js';
+
+/**
+ * Electron, preload and renderer side. Nothing here touches Node.
+ *
+ *   preload:   exposeUpdater(contextBridge, ipcRenderer)
+ *   renderer:  const updater = rendererUpdater()   // an UpdaterLike for useUpdater / UpdatePrompt
+ */
+
+interface IpcRendererLike {
+    invoke(channel: string, ...args: unknown[]): Promise<unknown>;
+    send(channel: string, ...args: unknown[]): void;
+    on(channel: string, listener: (event: unknown, ...args: unknown[]) => void): unknown;
+    removeListener(channel: string, listener: (event: unknown, ...args: unknown[]) => void): unknown;
+}
+interface ContextBridgeLike {
+    exposeInMainWorld(key: string, api: unknown): void;
+}
+/** What the preload puts on window.subaru. */
+interface SubaruBridge {
+    get(): Promise<UpdaterState>;
+    onState(listener: (state: UpdaterState) => void): () => void;
+    check(): void;
+    install(): void;
+    restart(): void;
+    skip(): void;
+    dismiss(): void;
+}
+/** Call from the preload script. */
+declare function exposeUpdater(contextBridge: ContextBridgeLike, ipcRenderer: IpcRendererLike, key?: string): void;
+/** Call from the renderer. Reads the bridge the preload exposed. */
+declare function rendererUpdater(bridge?: SubaruBridge): UpdaterLike;
+
+export { type ContextBridgeLike, type IpcRendererLike, type SubaruBridge, exposeUpdater, rendererUpdater };

package/dist/electron-renderer.js

@@ -0,0 +1,81 @@
+// src/electron-renderer.ts
+var CHANNELS = {
+  state: "subaru:state",
+  get: "subaru:get",
+  check: "subaru:check",
+  install: "subaru:install",
+  restart: "subaru:restart",
+  skip: "subaru:skip",
+  dismiss: "subaru:dismiss"
+};
+function exposeUpdater(contextBridge, ipcRenderer, key = "subaru") {
+  const bridge = {
+    get: () => ipcRenderer.invoke(CHANNELS.get),
+    onState(listener) {
+      const wrapped = (_event, state) => listener(state);
+      ipcRenderer.on(CHANNELS.state, wrapped);
+      return () => ipcRenderer.removeListener(CHANNELS.state, wrapped);
+    },
+    check: () => ipcRenderer.send(CHANNELS.check),
+    install: () => ipcRenderer.send(CHANNELS.install),
+    restart: () => ipcRenderer.send(CHANNELS.restart),
+    skip: () => ipcRenderer.send(CHANNELS.skip),
+    dismiss: () => ipcRenderer.send(CHANNELS.dismiss)
+  };
+  contextBridge.exposeInMainWorld(key, bridge);
+}
+var idle = {
+  status: "idle",
+  policy: "prompt",
+  release: null,
+  progress: null,
+  error: null,
+  skipped: false,
+  dismissed: false,
+  kind: "electron"
+};
+function rendererUpdater(bridge) {
+  const api = bridge ?? globalThis.subaru;
+  if (!api) throw new Error("subaru: window.subaru is missing; call exposeUpdater in the preload script");
+  let state = idle;
+  const listeners = /* @__PURE__ */ new Set();
+  api.onState((next) => {
+    state = next;
+    for (const l of listeners) l(state);
+  });
+  void api.get().then((initial) => {
+    if (initial) {
+      state = initial;
+      for (const l of listeners) l(state);
+    }
+  });
+  return {
+    getState: () => state,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    async check() {
+      api.check();
+    },
+    async install() {
+      api.install();
+    },
+    async restart() {
+      api.restart();
+    },
+    async skip() {
+      api.skip();
+    },
+    dismiss() {
+      api.dismiss();
+    }
+  };
+}
+export {
+  exposeUpdater,
+  rendererUpdater
+};
+//# sourceMappingURL=electron-renderer.js.map

package/dist/electron-renderer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/electron-renderer.ts"],"sourcesContent":["/**\n * Electron, preload and renderer side. Nothing here touches Node.\n *\n *   preload:   exposeUpdater(contextBridge, ipcRenderer)\n *   renderer:  const updater = rendererUpdater()   // an UpdaterLike for useUpdater / UpdatePrompt\n */\nimport type { UpdaterLike, UpdaterState } from './core';\n\nconst CHANNELS = {\n  state: 'subaru:state',\n  get: 'subaru:get',\n  check: 'subaru:check',\n  install: 'subaru:install',\n  restart: 'subaru:restart',\n  skip: 'subaru:skip',\n  dismiss: 'subaru:dismiss',\n} as const;\n\nexport interface IpcRendererLike {\n  invoke(channel: string, ...args: unknown[]): Promise<unknown>;\n  send(channel: string, ...args: unknown[]): void;\n  on(channel: string, listener: (event: unknown, ...args: unknown[]) => void): unknown;\n  removeListener(channel: string, listener: (event: unknown, ...args: unknown[]) => void): unknown;\n}\n\nexport interface ContextBridgeLike {\n  exposeInMainWorld(key: string, api: unknown): void;\n}\n\n/** What the preload puts on window.subaru. */\nexport interface SubaruBridge {\n  get(): Promise<UpdaterState>;\n  onState(listener: (state: UpdaterState) => void): () => void;\n  check(): void;\n  install(): void;\n  restart(): void;\n  skip(): void;\n  dismiss(): void;\n}\n\n/** Call from the preload script. */\nexport function exposeUpdater(contextBridge: ContextBridgeLike, ipcRenderer: IpcRendererLike, key = 'subaru'): void {\n  const bridge: SubaruBridge = {\n    get: () => ipcRenderer.invoke(CHANNELS.get) as Promise<UpdaterState>,\n    onState(listener) {\n      const wrapped = (_event: unknown, state: unknown) => listener(state as UpdaterState);\n      ipcRenderer.on(CHANNELS.state, wrapped);\n      return () => ipcRenderer.removeListener(CHANNELS.state, wrapped);\n    },\n    check: () => ipcRenderer.send(CHANNELS.check),\n    install: () => ipcRenderer.send(CHANNELS.install),\n    restart: () => ipcRenderer.send(CHANNELS.restart),\n    skip: () => ipcRenderer.send(CHANNELS.skip),\n    dismiss: () => ipcRenderer.send(CHANNELS.dismiss),\n  };\n  contextBridge.exposeInMainWorld(key, bridge);\n}\n\nconst idle: UpdaterState = {\n  status: 'idle',\n  policy: 'prompt',\n  release: null,\n  progress: null,\n  error: null,\n  skipped: false,\n  dismissed: false,\n  kind: 'electron',\n};\n\n/** Call from the renderer. Reads the bridge the preload exposed. */\nexport function rendererUpdater(bridge?: SubaruBridge): UpdaterLike {\n  const api = bridge ?? (globalThis as unknown as { subaru?: SubaruBridge }).subaru;\n  if (!api) throw new Error('subaru: window.subaru is missing; call exposeUpdater in the preload script');\n  let state = idle;\n  const listeners = new Set<(s: UpdaterState) => void>();\n  api.onState((next) => {\n    state = next;\n    for (const l of listeners) l(state);\n  });\n  void api.get().then((initial) => {\n    if (initial) {\n      state = initial;\n      for (const l of listeners) l(state);\n    }\n  });\n  return {\n    getState: () => state,\n    subscribe(listener) {\n      listeners.add(listener);\n      return () => {\n        listeners.delete(listener);\n      };\n    },\n    async check() {\n      api.check();\n    },\n    async install() {\n      api.install();\n    },\n    async restart() {\n      api.restart();\n    },\n    async skip() {\n      api.skip();\n    },\n    dismiss() {\n      api.dismiss();\n    },\n  };\n}\n"],"mappings":";AAQA,IAAM,WAAW;AAAA,EACf,OAAO;AAAA,EACP,KAAK;AAAA,EACL,OAAO;AAAA,EACP,SAAS;AAAA,EACT,SAAS;AAAA,EACT,MAAM;AAAA,EACN,SAAS;AACX;AAyBO,SAAS,cAAc,eAAkC,aAA8B,MAAM,UAAgB;AAClH,QAAM,SAAuB;AAAA,IAC3B,KAAK,MAAM,YAAY,OAAO,SAAS,GAAG;AAAA,IAC1C,QAAQ,UAAU;AAChB,YAAM,UAAU,CAAC,QAAiB,UAAmB,SAAS,KAAqB;AACnF,kBAAY,GAAG,SAAS,OAAO,OAAO;AACtC,aAAO,MAAM,YAAY,eAAe,SAAS,OAAO,OAAO;AAAA,IACjE;AAAA,IACA,OAAO,MAAM,YAAY,KAAK,SAAS,KAAK;AAAA,IAC5C,SAAS,MAAM,YAAY,KAAK,SAAS,OAAO;AAAA,IAChD,SAAS,MAAM,YAAY,KAAK,SAAS,OAAO;AAAA,IAChD,MAAM,MAAM,YAAY,KAAK,SAAS,IAAI;AAAA,IAC1C,SAAS,MAAM,YAAY,KAAK,SAAS,OAAO;AAAA,EAClD;AACA,gBAAc,kBAAkB,KAAK,MAAM;AAC7C;AAEA,IAAM,OAAqB;AAAA,EACzB,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,UAAU;AAAA,EACV,OAAO;AAAA,EACP,SAAS;AAAA,EACT,WAAW;AAAA,EACX,MAAM;AACR;AAGO,SAAS,gBAAgB,QAAoC;AAClE,QAAM,MAAM,UAAW,WAAoD;AAC3E,MAAI,CAAC,IAAK,OAAM,IAAI,MAAM,4EAA4E;AACtG,MAAI,QAAQ;AACZ,QAAM,YAAY,oBAAI,IAA+B;AACrD,MAAI,QAAQ,CAAC,SAAS;AACpB,YAAQ;AACR,eAAW,KAAK,UAAW,GAAE,KAAK;AAAA,EACpC,CAAC;AACD,OAAK,IAAI,IAAI,EAAE,KAAK,CAAC,YAAY;AAC/B,QAAI,SAAS;AACX,cAAQ;AACR,iBAAW,KAAK,UAAW,GAAE,KAAK;AAAA,IACpC;AAAA,EACF,CAAC;AACD,SAAO;AAAA,IACL,UAAU,MAAM;AAAA,IAChB,UAAU,UAAU;AAClB,gBAAU,IAAI,QAAQ;AACtB,aAAO,MAAM;AACX,kBAAU,OAAO,QAAQ;AAAA,MAC3B;AAAA,IACF;AAAA,IACA,MAAM,QAAQ;AACZ,UAAI,MAAM;AAAA,IACZ;AAAA,IACA,MAAM,UAAU;AACd,UAAI,QAAQ;AAAA,IACd;AAAA,IACA,MAAM,UAAU;AACd,UAAI,QAAQ;AAAA,IACd;AAAA,IACA,MAAM,OAAO;AACX,UAAI,KAAK;AAAA,IACX;AAAA,IACA,UAAU;AACR,UAAI,QAAQ;AAAA,IACd;AAAA,EACF;AACF;","names":[]}

package/dist/electron.d.ts

@@ -0,0 +1,239 @@
+import { P as Policy, A as Adapter, b as Updater } from './core-DmEjLKLp.js';
+import { F as FetchLike, G as GitHubAsset } from './github-Ds4DWDq9.js';
+import { Runner, SourceAdapterOptions } from './source.js';
+
+/**
+ * Electron, main-process side.
+ *
+ *   subaru('owner/repo')          — the whole integration in one call: the
+ *                                   bundle adapter below, a native dialog,
+ *                                   and the daily check.
+ *   bundleAdapter({ repo })       — an Adapter that downloads the app from
+ *                                   GitHub Releases and swaps it in place:
+ *                                   the .app on macOS, the AppImage or the
+ *                                   unpacked directory on Linux. Signed or
+ *                                   unsigned; no electron-updater, no source
+ *                                   checkout.
+ *   electronAdapter(autoUpdater)  — an Adapter over electron-updater, which
+ *                                   downloads and applies releases published
+ *                                   by electron-builder (Windows, or apps
+ *                                   already on it).
+ *   serveUpdater(updater, ipc)    — mirrors the updater over IPC so the
+ *                                   renderer can show the same prompt through
+ *                                   "@justin06lee/subaru/electron/renderer".
+ *   nodeRunner()                  — runs git and make for sourceAdapter
+ *                                   (source mode: unsigned apps that a
+ *                                   Makefile builds and installs).
+ */
+
+/** The slice of electron-updater's AppUpdater subaru uses. */
+interface ElectronAutoUpdater {
+    autoDownload: boolean;
+    autoInstallOnAppQuit: boolean;
+    allowPrerelease: boolean;
+    checkForUpdates(): Promise<{
+        isUpdateAvailable: boolean;
+        updateInfo: ElectronUpdateInfo;
+    } | null>;
+    downloadUpdate(): Promise<unknown>;
+    quitAndInstall(isSilent?: boolean, isForceRunAfter?: boolean): void;
+    on(event: 'download-progress', listener: (progress: {
+        percent: number;
+    }) => void): unknown;
+    off(event: 'download-progress', listener: (progress: {
+        percent: number;
+    }) => void): unknown;
+}
+interface ElectronUpdateInfo {
+    version: string;
+    releaseName?: string | null;
+    releaseNotes?: string | Array<{
+        version: string;
+        note: string | null;
+    }> | null;
+    releaseDate?: string;
+}
+interface ElectronAdapterOptions {
+    allowPrerelease?: boolean;
+    /** Where to keep state. Default: no persistence beyond the process; pass fileStorage(join(app.getPath('userData'), 'subaru.json')). */
+    storagePath?: string;
+}
+declare function electronAdapter(autoUpdater: ElectronAutoUpdater, options?: ElectronAdapterOptions): Adapter;
+/** The IPC surface subaru uses, so tests can pass a fake and apps pass Electron's. */
+interface IpcMainLike {
+    handle(channel: string, listener: (event: unknown, ...args: unknown[]) => unknown): void;
+    on(channel: string, listener: (event: unknown, ...args: unknown[]) => void): unknown;
+}
+interface WebContentsLike {
+    send(channel: string, ...args: unknown[]): void;
+    isDestroyed?(): boolean;
+}
+declare const IPC: {
+    readonly state: "subaru:state";
+    readonly get: "subaru:get";
+    readonly check: "subaru:check";
+    readonly install: "subaru:install";
+    readonly restart: "subaru:restart";
+    readonly skip: "subaru:skip";
+    readonly dismiss: "subaru:dismiss";
+};
+/**
+ * Publish the updater to renderers: state changes are pushed on
+ * "subaru:state", and the renderer's actions arrive on the other channels.
+ * `targets` returns the webContents that should receive state (usually every
+ * BrowserWindow's).
+ */
+declare function serveUpdater(updater: Updater, ipcMain: IpcMainLike, targets: () => WebContentsLike[]): () => void;
+interface NodeRunnerOptions {
+    /** Where a detached `make update` writes its output. Default: subaru-update.log in the temp dir. */
+    log?: string;
+    env?: Record<string, string | undefined>;
+}
+/**
+ * A Runner on Node's child_process for sourceAdapter. Detached requests are
+ * started in their own session with output appended to a log file, so
+ * `make update` keeps going after it has quit this program. PATH gains the
+ * usual tool directories a Finder-launched app lacks (Homebrew, bun, go,
+ * cargo).
+ */
+declare function nodeRunner(options?: NodeRunnerOptions): Runner;
+/** The slice of Electron's `app` the bundle adapter and subaru() use. */
+interface AppLike {
+    getName(): string;
+    getVersion(): string;
+    getPath(name: 'exe' | 'userData' | 'temp'): string;
+    relaunch(options?: {
+        execPath?: string;
+        args?: string[];
+    }): void;
+    exit(code?: number): void;
+    isPackaged: boolean;
+    whenReady(): Promise<void>;
+}
+/**
+ * How the macOS app is signed, which decides what happens to its permission
+ * grants (Accessibility, Screen Recording, ...) across an update.
+ *
+ *   'unsigned' — ad-hoc or no signature. Every build is a new identity to
+ *                macOS, so grants cannot survive; subaru resets the stale
+ *                ones (resetPermissions) so the new build asks again.
+ *   'signed'   — a stable signing identity (Developer ID, or any certificate
+ *                you sign every build with). The new bundle must satisfy the
+ *                running bundle's designated requirement, the same check
+ *                macOS uses for grants, or it is refused before anything is
+ *                replaced; grants carry over and nothing is reset.
+ *
+ * Ignored on Linux, which has no equivalent.
+ */
+type Signing = 'unsigned' | 'signed';
+interface BundleAdapterOptions {
+    /** "owner/name" on GitHub. */
+    repo: string;
+    app?: AppLike;
+    /** Program name used to pick the asset (`<name>-darwin-arm64.zip`). Default: the app name, lowercased. */
+    name?: string;
+    /** Running version. Default app.getVersion(). */
+    currentVersion?: string;
+    /** Default 'unsigned'. */
+    signing?: Signing;
+    /**
+     * macOS permission services to reset before relaunching an unsigned
+     * build, so it asks again instead of sitting on a stale grant: e.g.
+     * ["Accessibility", "ScreenCapture", "ListenEvent"]. Needs the bundle id
+     * (read from the bundle when not given). Not used when signing is
+     * 'signed': the grants are still valid.
+     */
+    resetPermissions?: string[];
+    bundleId?: string;
+    requireChecksum?: boolean;
+    fetch?: FetchLike;
+    /** Runs ditto, tar, unzip, xattr, codesign, tccutil. Default: nodeRunner(). */
+    run?: Runner;
+    /** Test hooks. */
+    bundlePath?: string;
+    platform?: string;
+    arch?: string;
+    api?: string;
+    allowAnyHost?: boolean;
+    env?: Record<string, string | undefined>;
+}
+/**
+ * Installs releases the way Tauri's updater does, with nothing but an
+ * archive on GitHub Releases.
+ *
+ *   macOS   `<name>-darwin-<arch>.zip` (or .tar.gz) holding the .app,
+ *           unpacked with ditto so symlinks and signatures survive, swapped
+ *           in place of the running bundle.
+ *   Linux   run as an AppImage: `<name>-linux-<arch>.AppImage` replaces the
+ *           file $APPIMAGE points at. Run from an unpacked directory
+ *           (electron-builder's linux-unpacked, a tarball in ~/.local or
+ *           /opt): `<name>-linux-<arch>.tar.gz` (or .zip) replaces the
+ *           directory the executable lives in.
+ *
+ * The published checksum is verified first, the new copy is staged next to
+ * the old one so the swap is a rename on one filesystem, and a failure at
+ * any step leaves the running app where it was.
+ */
+declare function bundleAdapter(options: BundleAdapterOptions): Adapter;
+/**
+ * The asset for this platform in the shape the install needs: an AppImage,
+ * or a .zip / .tar.gz archive. Raw binaries (a Go program's assets in the
+ * same release) are never picked.
+ */
+declare function pickBundleAsset(assets: GitHubAsset[], name: string, os: string, arch: string, form: 'appimage' | 'archive'): GitHubAsset | null;
+interface ElectronAutoOptions {
+    policy?: Policy;
+    /** Shown in the dialog. Default app.getName(). */
+    name?: string;
+    /** Source mode instead of GitHub Releases: the app's git checkout, fast-forwarded and rebuilt with make. */
+    checkout?: string;
+    source?: Omit<SourceAdapterOptions, 'checkout' | 'run'> & {
+        run?: Runner;
+    };
+    /** Passed to bundleAdapter. 'signed' keeps macOS permission grants across updates; default 'unsigned'. */
+    signing?: Signing;
+    resetPermissions?: string[];
+    bundleId?: string;
+    requireChecksum?: boolean;
+    /** false: no native dialog; drive the UI yourself (serveUpdater + the card in the renderer). */
+    dialog?: boolean;
+    /** Mirror state to renderers too. */
+    ipcMain?: IpcMainLike;
+    windows?: () => WebContentsLike[];
+    debug?: (message: string) => void;
+    /** Test hooks: Electron's app and dialog. */
+    electron?: {
+        app: AppLike;
+        dialog?: DialogLike;
+    };
+    adapter?: Adapter;
+}
+interface DialogLike {
+    showMessageBox(options: {
+        type?: string;
+        message: string;
+        detail?: string;
+        buttons: string[];
+        defaultId?: number;
+        cancelId?: number;
+    }): Promise<{
+        response: number;
+    }>;
+}
+/**
+ * The whole integration in one call, from the main process:
+ *
+ *   import { subaru } from '@justin06lee/subaru/electron';
+ *   subaru('justin06lee/ruri');
+ *
+ * Once a day it looks at the repository's latest release. When there is a
+ * newer one it asks with a native dialog (Update now / Skip this version /
+ * Later), downloads the release for this platform, swaps it in and
+ * relaunches. Nothing needs publishing beyond a GitHub release; signing is
+ * optional, and { signing: 'signed' } keeps macOS permission grants.
+ * Pass { checkout } for source mode instead. Development runs (app.isPackaged
+ * false) stay off unless a policy is given.
+ */
+declare function subaru(repo: string, options?: ElectronAutoOptions): Promise<Updater>;
+
+export { type AppLike, type BundleAdapterOptions, type DialogLike, type ElectronAdapterOptions, type ElectronAutoOptions, type ElectronAutoUpdater, type ElectronUpdateInfo, IPC, type IpcMainLike, type NodeRunnerOptions, type Signing, type WebContentsLike, bundleAdapter, electronAdapter, nodeRunner, pickBundleAsset, serveUpdater, subaru };