@dimina-kit/devtools 0.1.0 → 0.2.0-dev.20260424031451

package/dist/main/services/automation/index.d.ts

@@ -14,5 +14,6 @@ export interface AutomationServer {
     close: () => void;
     port: number;
 }
-export declare function startAutomationServer(ctx: WorkbenchContext, port: number): AutomationServer;
+export declare function getAutomationPort(): number | null;
+export declare function startAutomationServer(ctx: WorkbenchContext, port?: number): Promise<AutomationServer>;
 //# sourceMappingURL=index.d.ts.map

package/dist/main/services/automation/index.js

@@ -9,9 +9,9 @@
  * This server handles these messages by delegating to the workbench context
  * (simulator webContents, IPC handlers, etc.) without modifying dimina upstream.
  */
-/// <reference types="electron" />
+import { ipcMain } from 'electron';
 import { WebSocketServer } from 'ws';
-import { SimulatorChannel } from '../../../shared/ipc-channels.js';
+import { AutomationChannel, SimulatorChannel } from '../../../shared/ipc-channels.js';
 import { getSimulator } from './exec.js';
 import { toolHandlers } from './handlers/tool.js';
 import { appHandlers } from './handlers/app.js';
@@ -24,9 +24,26 @@ const handlers = {
     ...pageHandlers,
     ...elementHandlers,
 };
-export function startAutomationServer(ctx, port) {
+let currentPort = null;
+let portIpcRegistered = false;
+export function getAutomationPort() {
+    return currentPort;
+}
+export async function startAutomationServer(ctx, port = 0) {
     const wss = new WebSocketServer({ port });
     const clients = new Set();
+    await new Promise((resolve, reject) => {
+        wss.once('listening', () => resolve());
+        wss.once('error', (err) => reject(err));
+    });
+    const addr = wss.address();
+    // ws always binds via an http.Server, so address() is AddressInfo here.
+    const resolvedPort = typeof addr === 'object' && addr ? addr.port : port;
+    currentPort = resolvedPort;
+    if (!portIpcRegistered) {
+        portIpcRegistered = true;
+        ipcMain.handle(AutomationChannel.GetPort, () => currentPort);
+    }
     function broadcast(event) {
         const msg = JSON.stringify(event);
         for (const ws of clients) {
@@ -90,6 +107,13 @@ export function startAutomationServer(ctx, port) {
         });
         ws.on('close', () => clients.delete(ws));
     });
-    return { close: () => wss.close(), port };
+    return {
+        close: () => {
+            if (currentPort === resolvedPort)
+                currentPort = null;
+            wss.close();
+        },
+        port: resolvedPort,
+    };
 }
 //# sourceMappingURL=index.js.map

package/dist/main/services/projects/project-repository.js

@@ -22,6 +22,12 @@ export function listProjects() {
     return load();
 }
 export function validateProjectDir(dirPath) {
+    if (!dirPath) {
+        return '小程序目录路径为空，请选择包含小程序源码的目录';
+    }
+    if (!fs.existsSync(dirPath)) {
+        return `小程序目录不存在：${dirPath}`;
+    }
     if (!fs.existsSync(path.join(dirPath, 'app.json'))) {
         const configPath = path.join(dirPath, 'project.config.json');
         if (fs.existsSync(configPath)) {

package/dist/main/services/simulator-storage/index.d.ts

@@ -0,0 +1,20 @@
+/**
+ * SimulatorStorageWatcher
+ *
+ * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
+ * and forwards `DOMStorage.*` events to the renderer host. Replaces the
+ * preload-side localStorage.setItem hook that used to push storage changes
+ * via SimulatorChannel.Storage / StorageAll.
+ *
+ * Trade-offs vs the preload approach:
+ *   + Uses standard browser protocol; no preload injection
+ *   + Captures every change including ones bypassing wx (api-compat fallback,
+ *     direct localStorage.setItem from devtools, etc.)
+ *   + Decouples panel UI from dimina runtime's wx implementation
+ *   - debugger.attach is mutually exclusive with Chrome DevTools (F12).
+ *     If a user opens DevTools on the simulator the debugger detaches and
+ *     events stop flowing until they close it.
+ */
+import { type WebContents } from 'electron';
+export declare function setupSimulatorStorage(host: WebContents): void;
+//# sourceMappingURL=index.d.ts.map

package/dist/main/services/simulator-storage/index.js

@@ -0,0 +1,136 @@
+/**
+ * SimulatorStorageWatcher
+ *
+ * Attaches the Chrome DevTools Protocol debugger to the simulator <webview>
+ * and forwards `DOMStorage.*` events to the renderer host. Replaces the
+ * preload-side localStorage.setItem hook that used to push storage changes
+ * via SimulatorChannel.Storage / StorageAll.
+ *
+ * Trade-offs vs the preload approach:
+ *   + Uses standard browser protocol; no preload injection
+ *   + Captures every change including ones bypassing wx (api-compat fallback,
+ *     direct localStorage.setItem from devtools, etc.)
+ *   + Decouples panel UI from dimina runtime's wx implementation
+ *   - debugger.attach is mutually exclusive with Chrome DevTools (F12).
+ *     If a user opens DevTools on the simulator the debugger detaches and
+ *     events stop flowing until they close it.
+ */
+import { app, ipcMain, webContents as wcStatic } from 'electron';
+import { SimulatorStorageChannel, } from '../../../shared/ipc-channels.js';
+let attachedWc = null;
+let hostWc = null;
+function isSimulatorWebview(wc) {
+    if (wc.isDestroyed())
+        return false;
+    if (wc.getType() !== 'webview')
+        return false;
+    return wc.getURL().includes('simulator.html');
+}
+function detach() {
+    if (!attachedWc)
+        return;
+    const wc = attachedWc;
+    attachedWc = null;
+    try {
+        if (!wc.isDestroyed() && wc.debugger.isAttached()) {
+            wc.debugger.detach();
+        }
+    }
+    catch {
+        // best-effort
+    }
+}
+async function attachToSim(wc) {
+    if (attachedWc === wc)
+        return;
+    if (wc.isDestroyed())
+        return;
+    detach();
+    try {
+        if (!wc.debugger.isAttached()) {
+            wc.debugger.attach('1.3');
+        }
+        await wc.debugger.sendCommand('DOMStorage.enable');
+        wc.debugger.on('message', onCdpMessage);
+        wc.debugger.on('detach', () => {
+            if (attachedWc === wc)
+                attachedWc = null;
+        });
+        wc.once('destroyed', () => {
+            if (attachedWc === wc)
+                attachedWc = null;
+        });
+        attachedWc = wc;
+    }
+    catch (e) {
+        console.warn('[storage-watcher] attach failed:', e.message);
+    }
+}
+function onCdpMessage(_event, method, params) {
+    if (!hostWc || hostWc.isDestroyed())
+        return;
+    const p = params;
+    let evt;
+    switch (method) {
+        case 'DOMStorage.domStorageItemAdded':
+            evt = { type: 'added', key: String(p.key), newValue: String(p.newValue ?? '') };
+            break;
+        case 'DOMStorage.domStorageItemUpdated':
+            evt = {
+                type: 'updated',
+                key: String(p.key),
+                oldValue: String(p.oldValue ?? ''),
+                newValue: String(p.newValue ?? ''),
+            };
+            break;
+        case 'DOMStorage.domStorageItemRemoved':
+            evt = { type: 'removed', key: String(p.key) };
+            break;
+        case 'DOMStorage.domStorageItemsCleared':
+            evt = { type: 'cleared' };
+            break;
+        default:
+            return;
+    }
+    hostWc.send(SimulatorStorageChannel.Event, evt);
+}
+async function getSnapshot() {
+    if (!attachedWc || attachedWc.isDestroyed())
+        return [];
+    try {
+        const origin = await attachedWc.executeJavaScript('location.origin');
+        const result = (await attachedWc.debugger.sendCommand('DOMStorage.getDOMStorageItems', {
+            storageId: { securityOrigin: origin, isLocalStorage: true },
+        }));
+        return result.entries.map(([key, value]) => ({ key, value }));
+    }
+    catch {
+        return [];
+    }
+}
+export function setupSimulatorStorage(host) {
+    hostWc = host;
+    // Attach to any simulator webview that already exists (project may have
+    // been opened before this function runs).
+    for (const wc of wcStatic.getAllWebContents()) {
+        if (isSimulatorWebview(wc)) {
+            void attachToSim(wc);
+            break;
+        }
+    }
+    // Catch new simulator webviews on creation. did-finish-load is the right
+    // moment because getURL() may still be 'about:blank' at creation.
+    app.on('web-contents-created', (_event, wc) => {
+        wc.on('did-finish-load', () => {
+            if (isSimulatorWebview(wc)) {
+                void attachToSim(wc);
+            }
+        });
+        wc.on('did-navigate-in-page', () => {
+            // Project switched but same webview — attach already correct, debugger
+            // session survives in-page navigations. No-op.
+        });
+    });
+    ipcMain.handle(SimulatorStorageChannel.GetSnapshot, getSnapshot);
+}
+//# sourceMappingURL=index.js.map

package/dist/main/services/update/github-release-checker.d.ts

@@ -0,0 +1,49 @@
+import type { UpdateChecker } from '../../../shared/types.js';
+interface GitHubReleaseAsset {
+    name: string;
+    browser_download_url: string;
+    size: number;
+}
+interface GitHubRelease {
+    tag_name: string;
+    name?: string;
+    body?: string;
+    prerelease: boolean;
+    draft: boolean;
+    assets: GitHubReleaseAsset[];
+}
+export type VersionScheme = 'semver' | 'trailing-number';
+export interface GitHubReleaseCheckerOptions {
+    owner: string;
+    repo: string;
+    /** Optional GitHub token (required for private repos; recommended to avoid rate limits). */
+    token?: string;
+    /** Include prereleases when resolving the latest version. Default: false. */
+    includePrereleases?: boolean;
+    /** Mark every delivered update as mandatory. Default: false. */
+    mandatory?: boolean;
+    /**
+     * Built-in version scheme. Ignored when `parseVersion` is supplied.
+     * - `'semver'` (default): extract `x.y.z` from `tag_name` → release name → first asset name.
+     * - `'trailing-number'`: treat the trailing `-<N>` in `tag_name` as the version
+     *   (e.g. `release-20260422-1` → `'1'`). Compared as an integer.
+     */
+    versionScheme?: VersionScheme;
+    /**
+     * Custom asset picker. Receives the release assets plus the current
+     * process platform/arch. If omitted, a built-in picker is used that
+     * matches by file extension and arch suffix.
+     */
+    pickAsset?: (assets: GitHubReleaseAsset[], ctx: PickAssetContext) => GitHubReleaseAsset | undefined;
+    /**
+     * Extract the version string from a release. Overrides `versionScheme`.
+     */
+    parseVersion?: (release: GitHubRelease) => string | null;
+}
+export interface PickAssetContext {
+    platform: NodeJS.Platform;
+    arch: string;
+}
+export declare function createGitHubReleaseChecker(opts: GitHubReleaseCheckerOptions): UpdateChecker;
+export {};
+//# sourceMappingURL=github-release-checker.d.ts.map

package/dist/main/services/update/github-release-checker.js

@@ -0,0 +1,248 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { app } from 'electron';
+export function createGitHubReleaseChecker(opts) {
+    const releaseUrl = opts.includePrereleases
+        ? `https://api.github.com/repos/${opts.owner}/${opts.repo}/releases`
+        : `https://api.github.com/repos/${opts.owner}/${opts.repo}/releases/latest`;
+    const parseVersion = opts.parseVersion ?? schemeParser(opts.versionScheme ?? 'semver');
+    return {
+        async checkForUpdates(currentVersion) {
+            const release = await fetchRelease(releaseUrl, opts);
+            if (!release)
+                return null;
+            const latestVersion = parseVersion(release);
+            if (!latestVersion)
+                return null;
+            if (compareSemver(latestVersion, stripV(currentVersion)) <= 0)
+                return null;
+            const asset = (opts.pickAsset ?? defaultPickAsset)(release.assets, {
+                platform: process.platform,
+                arch: process.arch,
+            });
+            if (!asset)
+                return null;
+            return {
+                version: latestVersion,
+                downloadUrl: asset.browser_download_url,
+                releaseNotes: release.body,
+                mandatory: opts.mandatory,
+            };
+        },
+        async downloadUpdate(info, onProgress) {
+            const tmpDir = path.join(app.getPath('temp'), `${opts.repo}-update`);
+            if (!fs.existsSync(tmpDir))
+                fs.mkdirSync(tmpDir, { recursive: true });
+            const fileName = path.basename(new URL(info.downloadUrl).pathname);
+            const filePath = path.join(tmpDir, fileName);
+            await downloadFile(info.downloadUrl, filePath, opts.token, onProgress);
+            return filePath;
+        },
+    };
+}
+// ── Default pickers ───────────────────────────────────────────────────────
+function defaultPickAsset(assets, ctx) {
+    const candidates = platformMatchers(ctx.platform, ctx.arch);
+    for (const match of candidates) {
+        const hit = assets.find((a) => match(a.name));
+        if (hit)
+            return hit;
+    }
+    return undefined;
+}
+function platformMatchers(platform, arch) {
+    const lc = (s) => s.toLowerCase();
+    const archTags = archAliases(arch);
+    const hasArch = (name) => archTags.some((tag) => lc(name).includes(tag));
+    const endsWith = (name, ext) => lc(name).endsWith(ext);
+    switch (platform) {
+        case 'darwin':
+            return [
+                (n) => endsWith(n, '.dmg') && hasArch(n),
+                (n) => endsWith(n, '.dmg'), // mac builds are often universal / unarch-tagged
+                (n) => endsWith(n, '.zip') && (lc(n).includes('mac') || lc(n).includes('darwin')),
+            ];
+        case 'win32':
+            return [
+                (n) => endsWith(n, '.exe') && hasArch(n),
+                (n) => endsWith(n, '.zip') && (lc(n).includes('win') || lc(n).includes('windows')) && hasArch(n),
+                (n) => endsWith(n, '.exe'),
+                (n) => endsWith(n, '.zip') && (lc(n).includes('win') || lc(n).includes('windows')),
+            ];
+        case 'linux':
+            return [
+                (n) => endsWith(n, '.appimage') && hasArch(n),
+                (n) => endsWith(n, '.tar.gz') && lc(n).includes('linux') && hasArch(n),
+                (n) => endsWith(n, '.appimage'),
+                (n) => endsWith(n, '.tar.gz') && lc(n).includes('linux'),
+                (n) => endsWith(n, '.deb') && hasArch(n),
+            ];
+        default:
+            return [];
+    }
+}
+function archAliases(arch) {
+    switch (arch) {
+        case 'x64':
+            return ['x64', 'x86_64', 'amd64'];
+        case 'arm64':
+            return ['arm64', 'aarch64'];
+        case 'ia32':
+            return ['ia32', 'x86', 'i386'];
+        default:
+            return [arch];
+    }
+}
+// ── Version parsing & comparison ──────────────────────────────────────────
+const SEMVER_RE = /(\d+)\.(\d+)\.(\d+)(?:[-+]([0-9A-Za-z.-]+))?/;
+const TRAILING_NUMBER_RE = /-(\d+)$/;
+function schemeParser(scheme) {
+    if (scheme === 'trailing-number') {
+        return (release) => {
+            const m = release.tag_name.match(TRAILING_NUMBER_RE);
+            return m ? m[1] : null;
+        };
+    }
+    return defaultParseVersion;
+}
+function defaultParseVersion(release) {
+    const fromTag = extractSemver(release.tag_name);
+    if (fromTag)
+        return fromTag;
+    if (release.name) {
+        const fromName = extractSemver(release.name);
+        if (fromName)
+            return fromName;
+    }
+    for (const asset of release.assets) {
+        const hit = extractSemver(asset.name);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+function extractSemver(input) {
+    const m = input.match(SEMVER_RE);
+    if (!m)
+        return null;
+    const [, major, minor, patch, pre] = m;
+    return pre ? `${major}.${minor}.${patch}-${pre}` : `${major}.${minor}.${patch}`;
+}
+function stripV(version) {
+    return version.replace(/^v/i, '');
+}
+function compareSemver(a, b) {
+    const [aCore, aPre] = splitPre(a);
+    const [bCore, bPre] = splitPre(b);
+    const [a1, a2, a3] = parseCore(aCore);
+    const [b1, b2, b3] = parseCore(bCore);
+    if (a1 !== b1)
+        return a1 - b1;
+    if (a2 !== b2)
+        return a2 - b2;
+    if (a3 !== b3)
+        return a3 - b3;
+    // Release > prerelease of same core.
+    if (!aPre && bPre)
+        return 1;
+    if (aPre && !bPre)
+        return -1;
+    if (!aPre && !bPre)
+        return 0;
+    return aPre.localeCompare(bPre);
+}
+function splitPre(v) {
+    const i = v.indexOf('-');
+    return i < 0 ? [v, null] : [v.slice(0, i), v.slice(i + 1)];
+}
+function parseCore(core) {
+    const parts = core.split('.').map((s) => parseInt(s, 10) || 0);
+    return [parts[0] ?? 0, parts[1] ?? 0, parts[2] ?? 0];
+}
+// ── HTTP helpers ──────────────────────────────────────────────────────────
+function ghHeaders(token) {
+    const headers = {
+        'User-Agent': 'dimina-kit-updater',
+        'Accept': 'application/vnd.github+json',
+        'X-GitHub-Api-Version': '2022-11-28',
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+async function fetchRelease(url, opts) {
+    const body = await httpGetText(url, { headers: ghHeaders(opts.token) });
+    if (!body)
+        return null;
+    if (opts.includePrereleases) {
+        const list = JSON.parse(body);
+        const first = list.find((r) => !r.draft);
+        return first ?? null;
+    }
+    const release = JSON.parse(body);
+    return release.draft ? null : release;
+}
+function httpGetText(url, init) {
+    return new Promise((resolve, reject) => {
+        const req = https.get(url, { headers: init.headers }, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+                res.resume();
+                resolve(httpGetText(res.headers.location, init));
+                return;
+            }
+            if (res.statusCode !== 200) {
+                res.resume();
+                resolve(null);
+                return;
+            }
+            let body = '';
+            res.setEncoding('utf8');
+            res.on('data', (chunk) => { body += chunk; });
+            res.on('end', () => resolve(body));
+        });
+        req.on('error', reject);
+    });
+}
+function downloadFile(url, dest, token, onProgress) {
+    return new Promise((resolve, reject) => {
+        const headers = ghHeaders(token);
+        // GitHub asset downloads redirect to signed S3 URLs; keep following them.
+        const attempt = (target, redirectsLeft) => {
+            const req = https.get(target, { headers }, (res) => {
+                if (res.statusCode &&
+                    res.statusCode >= 300 &&
+                    res.statusCode < 400 &&
+                    res.headers.location) {
+                    res.resume();
+                    if (redirectsLeft <= 0) {
+                        reject(new Error('Too many redirects'));
+                        return;
+                    }
+                    attempt(res.headers.location, redirectsLeft - 1);
+                    return;
+                }
+                if (res.statusCode !== 200) {
+                    res.resume();
+                    reject(new Error(`HTTP ${res.statusCode} while downloading update`));
+                    return;
+                }
+                const total = parseInt(res.headers['content-length'] || '0', 10);
+                let received = 0;
+                const out = fs.createWriteStream(dest);
+                res.on('data', (chunk) => {
+                    received += chunk.length;
+                    if (total > 0 && onProgress) {
+                        onProgress((received / total) * 100);
+                    }
+                });
+                res.pipe(out);
+                out.on('finish', () => { out.close(); resolve(); });
+                out.on('error', (err) => { fs.unlink(dest, () => { }); reject(err); });
+            });
+            req.on('error', (err) => { fs.unlink(dest, () => { }); reject(err); });
+        };
+        attempt(url, 5);
+    });
+}
+//# sourceMappingURL=github-release-checker.js.map

package/dist/main/services/update/index.d.ts

@@ -0,0 +1,5 @@
+export { UpdateManager } from './update-manager.js';
+export type { UpdateManagerOptions } from './update-manager.js';
+export { createGitHubReleaseChecker } from './github-release-checker.js';
+export type { GitHubReleaseCheckerOptions, PickAssetContext, VersionScheme, } from './github-release-checker.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/main/services/update/index.js

@@ -0,0 +1,3 @@
+export { UpdateManager } from './update-manager.js';
+export { createGitHubReleaseChecker } from './github-release-checker.js';
+//# sourceMappingURL=index.js.map

package/dist/main/services/update/update-manager.d.ts

@@ -0,0 +1,37 @@
+import { BrowserWindow } from 'electron';
+import type { UpdateChecker, UpdateInfo } from '../../../shared/types.js';
+export interface UpdateManagerOptions {
+    checker: UpdateChecker;
+    mainWindow: BrowserWindow;
+    /** Check interval in milliseconds. Default: 1 hour */
+    checkInterval?: number;
+    /** Delay before the first check after startup in ms. Default: 5000 */
+    initialDelay?: number;
+    /** Override the version string passed to the checker. Default: app.getVersion() */
+    getCurrentVersion?: () => string;
+}
+export declare class UpdateManager {
+    private checker;
+    private mainWindow;
+    private getCurrentVersion;
+    private latestUpdate;
+    private downloadedPath;
+    private timer;
+    private initialTimer;
+    constructor(opts: UpdateManagerOptions);
+    private registerIpc;
+    check(): Promise<{
+        hasUpdate: boolean;
+        info?: UpdateInfo;
+    }>;
+    download(): Promise<{
+        success: boolean;
+        filePath?: string;
+        error?: string;
+    }>;
+    install(): void;
+    dispose(): void;
+    private startPeriodicCheck;
+    private checkAndNotify;
+}
+//# sourceMappingURL=update-manager.d.ts.map

package/dist/main/services/update/update-manager.js

@@ -0,0 +1,90 @@
+import { app, ipcMain, shell } from 'electron';
+export class UpdateManager {
+    checker;
+    mainWindow;
+    getCurrentVersion;
+    latestUpdate = null;
+    downloadedPath = null;
+    timer = null;
+    initialTimer = null;
+    constructor(opts) {
+        this.checker = opts.checker;
+        this.mainWindow = opts.mainWindow;
+        this.getCurrentVersion = opts.getCurrentVersion ?? (() => app.getVersion());
+        this.registerIpc();
+        this.startPeriodicCheck(opts.checkInterval ?? 60 * 60 * 1000, opts.initialDelay ?? 5000);
+    }
+    registerIpc() {
+        ipcMain.handle('updates:check', async () => {
+            return this.check();
+        });
+        ipcMain.handle('updates:download', async () => {
+            return this.download();
+        });
+        ipcMain.handle('updates:install', async () => {
+            this.install();
+        });
+    }
+    async check() {
+        try {
+            const currentVersion = this.getCurrentVersion();
+            const info = await this.checker.checkForUpdates(currentVersion);
+            if (info) {
+                this.latestUpdate = info;
+                this.downloadedPath = null;
+                return { hasUpdate: true, info };
+            }
+            return { hasUpdate: false };
+        }
+        catch (err) {
+            console.warn('[UpdateManager] check failed:', err);
+            return { hasUpdate: false };
+        }
+    }
+    async download() {
+        if (!this.latestUpdate) {
+            return { success: false, error: 'No update available' };
+        }
+        try {
+            const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
+                this.mainWindow.webContents.send('updates:downloadProgress', { percent });
+            });
+            this.downloadedPath = filePath;
+            return { success: true, filePath };
+        }
+        catch (err) {
+            console.warn('[UpdateManager] download failed:', err);
+            return { success: false, error: String(err) };
+        }
+    }
+    install() {
+        if (this.downloadedPath) {
+            shell.openPath(this.downloadedPath);
+            app.quit();
+        }
+    }
+    dispose() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        if (this.initialTimer) {
+            clearTimeout(this.initialTimer);
+            this.initialTimer = null;
+        }
+        ipcMain.removeHandler('updates:check');
+        ipcMain.removeHandler('updates:download');
+        ipcMain.removeHandler('updates:install');
+    }
+    startPeriodicCheck(interval, initialDelay) {
+        this.initialTimer = setTimeout(() => void this.checkAndNotify(), initialDelay);
+        this.timer = setInterval(() => void this.checkAndNotify(), interval);
+    }
+    async checkAndNotify() {
+        const result = await this.check();
+        if (result.hasUpdate && result.info) {
+            this.mainWindow.webContents.send('updates:available', result.info);
+        }
+    }
+}
+//# sourceMappingURL=update-manager.js.map