@dimina-kit/devtools 0.4.0-dev.20260718085557 → 0.4.0-dev.20260718143821

package/dist/main/app/app.d.ts

@@ -32,5 +32,14 @@ export declare function runDevtoolsBootstrap(config?: WorkbenchAppConfig): void;
  * v2 `RuntimeBackend.assemble` reuses the exact same body (parity by shared
  * implementation, not behavioural re-creation).
  */
-export declare function createDevtoolsRuntime(config?: WorkbenchAppConfig): Promise<WorkbenchAppInstance>;
+export declare function createDevtoolsRuntime(config?: WorkbenchAppConfig, 
+/**
+ * Fired the instant the `WorkbenchAppInstance` exists — BEFORE `config.onSetup`
+ * is awaited below, which may run arbitrarily long host code (including
+ * loading the host-toolbar, which opens a live MessagePort). A caller that
+ * only learns `instance` from this function's return value would not see it
+ * until `onSetup` resolves, leaving a window where an app-quit teardown hook
+ * has nothing to dispose yet a live toolbar port already exists.
+ */
+onInstanceCreated?: (instance: WorkbenchAppInstance) => void): Promise<WorkbenchAppInstance>;
 //# sourceMappingURL=app.d.ts.map

package/dist/main/app/app.js

@@ -357,7 +357,16 @@ export function runDevtoolsBootstrap(config = {}) {
  * v2 `RuntimeBackend.assemble` reuses the exact same body (parity by shared
  * implementation, not behavioural re-creation).
  */
-export async function createDevtoolsRuntime(config = {}) {
+export async function createDevtoolsRuntime(config = {}, 
+/**
+ * Fired the instant the `WorkbenchAppInstance` exists — BEFORE `config.onSetup`
+ * is awaited below, which may run arbitrarily long host code (including
+ * loading the host-toolbar, which opens a live MessagePort). A caller that
+ * only learns `instance` from this function's return value would not see it
+ * until `onSetup` resolves, leaving a window where an app-quit teardown hook
+ * has nothing to dispose yet a live toolbar port already exists.
+ */
+onInstanceCreated) {
     // Self-gate on Electron readiness: this builds a BrowserWindow immediately, so
     // it must run after `app.whenReady()`. The framework backend path already
     // awaited it (idempotent no-op here); this guards any direct caller against
@@ -414,6 +423,7 @@ export async function createDevtoolsRuntime(config = {}) {
         registerSimulatorApi: (name, handler) => context.registry.add(toDisposable(context.simulatorApis.register(name, handler))),
         dispose: () => disposeContext(context),
     };
+    onInstanceCreated?.(instance);
     // Built-in simulator APIs: devtools-supplied wx.* implementations that run
     // in the main process. Hosts can override any of these in their onSetup by
     // re-registering the same name (last-write-wins on the Map).

package/dist/main/app/lifecycle.d.ts

@@ -1,3 +1,14 @@
 export declare function isAppQuitting(): boolean;
-export declare function registerAppLifecycle(): void;
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export declare function registerAppLifecycle(onBeforeQuit?: () => void): void;
 //# sourceMappingURL=lifecycle.d.ts.map

package/dist/main/app/lifecycle.js

@@ -8,7 +8,18 @@ let appIsQuitting = false;
 export function isAppQuitting() {
     return appIsQuitting;
 }
-export function registerAppLifecycle() {
+/**
+ * `onBeforeQuit`: invoked synchronously, once per `before-quit`, while
+ * Electron's main loop is still fully healthy — i.e. BEFORE `will-quit` and
+ * any window/WebContentsView destruction. Callers use this to tear down
+ * resources (child WebContentsViews, MessagePorts) that are unsafe to let
+ * survive into Chromium's native shutdown sequence, where a JS `'destroyed'`
+ * handler closing them can hit an already-torn-down native object. Isolated
+ * like `host-toolbar-port-channel.ts`'s `invokeReadyHandler`: a throwing
+ * callback must not stop `appIsQuitting` from flipping or escape as an
+ * uncaught exception out of Electron's event dispatch.
+ */
+export function registerAppLifecycle(onBeforeQuit) {
     app.on('window-all-closed', () => {
         globalShortcut.unregisterAll();
         app.quit();
@@ -16,6 +27,12 @@ export function registerAppLifecycle() {
     app.on('before-quit', () => {
         appIsQuitting = true;
         globalShortcut.unregisterAll();
+        try {
+            onBeforeQuit?.();
+        }
+        catch (err) {
+            console.error('[lifecycle] onBeforeQuit handler threw:', err);
+        }
     });
 }
 //# sourceMappingURL=lifecycle.js.map

package/dist/main/index.bundle.js

@@ -893,8 +893,8 @@ function registerProjectFsIpc(ctx) {
 
 // src/main/app/app.ts
 import { app as app15, BrowserWindow as BrowserWindow8, nativeImage, session as session4 } from "electron";
-import fs12 from "fs";
-import path24 from "path";
+import fs13 from "fs";
+import path25 from "path";
 
 // src/main/utils/paths.ts
 import fs3 from "fs";
@@ -1080,7 +1080,7 @@ var appIsQuitting = false;
 function isAppQuitting() {
   return appIsQuitting;
 }
-function registerAppLifecycle() {
+function registerAppLifecycle(onBeforeQuit) {
   app4.on("window-all-closed", () => {
     globalShortcut2.unregisterAll();
     app4.quit();
@@ -1088,6 +1088,11 @@ function registerAppLifecycle() {
   app4.on("before-quit", () => {
     appIsQuitting = true;
     globalShortcut2.unregisterAll();
+    try {
+      onBeforeQuit?.();
+    } catch (err2) {
+      console.error("[lifecycle] onBeforeQuit handler threw:", err2);
+    }
   });
 }
 
@@ -4068,8 +4073,8 @@ function createHostToolbarView(ctx, reconciler, deps) {
     hide() {
       hideHostToolbar();
     },
-    setPreloadPath(path25) {
-      hostToolbarPreloadOverride = path25;
+    setPreloadPath(path26) {
+      hostToolbarPreloadOverride = path26;
     },
     setHeightMode(mode) {
       if (mode !== "auto" && !(Number.isFinite(mode.fixed) && mode.fixed >= 0)) {
@@ -5867,7 +5872,7 @@ async function materializeTemplate(target, template, name) {
       `Template source missing on disk: ${template.source.path}`
     );
   }
-  fs7.cpSync(template.source.path, target, {
+  await fs7.promises.cp(template.source.path, target, {
     recursive: true,
     force: true
   });
@@ -10250,7 +10255,6 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
   });
   connectTarget("workbench").catch(() => {
   });
-  const server = buildServer();
   const transports = /* @__PURE__ */ new Map();
   const httpServer = createServer(async (req, res) => {
     const url = new URL(req.url ?? "/", `http://localhost`);
@@ -10258,7 +10262,14 @@ function startMcpServer(resolvedCdpPort, mcpPort) {
       const transport = new SSEServerTransport("/message", res);
       transports.set(transport.sessionId, transport);
       res.on("close", () => transports.delete(transport.sessionId));
-      await server.connect(transport);
+      try {
+        await buildServer().connect(transport);
+      } catch (err2) {
+        transports.delete(transport.sessionId);
+        if (!res.headersSent) res.writeHead(500).end("MCP connect failed");
+        else res.end();
+        console.error("[MCP] SSE connect failed:", err2);
+      }
     } else if (req.method === "POST" && url.pathname === "/message") {
       const sessionId = url.searchParams.get("sessionId") ?? "";
       const transport = transports.get(sessionId);
@@ -10607,13 +10618,13 @@ function createRenderInspector(options = {}) {
 import { toDisposable as toDisposable6 } from "@dimina-kit/electron-deck/main";
 
 // src/main/services/simulator-temp-files/store.ts
-function registerTempFile(store, path25, mime, bytes) {
+function registerTempFile(store, path26, mime, bytes) {
   const buf = Buffer.isBuffer(bytes) ? bytes : Buffer.from(new Uint8Array(bytes));
-  store.delete(path25);
-  store.set(path25, { bytes: buf, mime });
+  store.delete(path26);
+  store.set(path26, { bytes: buf, mime });
 }
-function revokeTempFile(store, path25) {
-  store.delete(path25);
+function revokeTempFile(store, path26) {
+  store.delete(path26);
 }
 function revokeAllTempFiles(store) {
   store.clear();
@@ -11041,10 +11052,10 @@ function setupSimulatorTempFiles(simSession) {
   const store = /* @__PURE__ */ new Map();
   const pendingWaiters = /* @__PURE__ */ new Map();
   let disposed = false;
-  function drainWaiters(path25) {
-    const list = pendingWaiters.get(path25);
+  function drainWaiters(path26) {
+    const list = pendingWaiters.get(path26);
     if (!list) return;
-    pendingWaiters.delete(path25);
+    pendingWaiters.delete(path26);
     for (const fn of list) fn();
   }
   function drainAllWaiters() {
@@ -11057,15 +11068,15 @@ function setupSimulatorTempFiles(simSession) {
   const registry = new IpcRegistry(simulatorOnlyPolicy);
   registry.on("simulator:temp-file:write", (_event, payload) => {
     if (disposed) return;
-    const { path: path25, mime, bytes } = payload;
-    registerTempFile(store, path25, mime, bytes);
+    const { path: path26, mime, bytes } = payload;
+    registerTempFile(store, path26, mime, bytes);
     enforceStoreCap(store);
-    drainWaiters(path25);
+    drainWaiters(path26);
   });
   registry.on("simulator:temp-file:revoke", (_event, payload) => {
     if (disposed) return;
-    const { path: path25 } = payload;
-    revokeTempFile(store, path25);
+    const { path: path26 } = payload;
+    revokeTempFile(store, path26);
   });
   registry.on("simulator:temp-file:revoke-all", () => {
     if (disposed) return;
@@ -11619,8 +11630,9 @@ var UpdateManager = class {
       const currentVersion = this.getCurrentVersion();
       const info = await this.checker.checkForUpdates(currentVersion);
       if (info) {
+        const isSameUpdate = this.latestUpdate?.version === info.version && this.latestUpdate?.downloadUrl === info.downloadUrl;
         this.latestUpdate = info;
-        this.downloadedPath = null;
+        if (!isSameUpdate) this.downloadedPath = null;
         return { hasUpdate: true, info };
       }
       return { hasUpdate: false };
@@ -11644,11 +11656,17 @@ var UpdateManager = class {
       return { success: false, error: String(err2) };
     }
   }
-  install() {
-    if (this.downloadedPath) {
-      shell3.openPath(this.downloadedPath);
-      app13.quit();
+  async install() {
+    if (!this.downloadedPath) {
+      return { success: false, error: "No update downloaded" };
     }
+    const failure = await shell3.openPath(this.downloadedPath);
+    if (failure) {
+      console.warn("[UpdateManager] install failed:", failure);
+      return { success: false, error: failure };
+    }
+    app13.quit();
+    return { success: true };
   }
   /**
    * Tear down timers + IPC handlers. Returns a Promise so callers that need
@@ -11681,7 +11699,249 @@ var UpdateManager = class {
 };
 
 // src/main/services/update/github-release-checker.ts
+import fs12 from "fs";
+import path24 from "path";
+import https from "https";
 import { app as app14 } from "electron";
+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 = path24.join(app14.getPath("temp"), `${opts.repo}-update`);
+      if (!fs12.existsSync(tmpDir)) fs12.mkdirSync(tmpDir, { recursive: true });
+      const fileName = path24.basename(new URL(info.downloadUrl).pathname);
+      const filePath = path24.join(tmpDir, fileName);
+      await downloadFile(info.downloadUrl, filePath, opts.token, onProgress);
+      return filePath;
+    }
+  };
+}
+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 void 0;
+}
+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];
+  }
+}
+var SEMVER_RE = /(\d+)\.(\d+)\.(\d+)(?:[-+]([0-9A-Za-z.-]+))?/;
+var 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;
+  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];
+}
+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);
+    const cleanup = () => fs12.promises.unlink(dest).catch(() => {
+    });
+    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 = fs12.createWriteStream(dest);
+        res.on("data", (chunk) => {
+          received += chunk.length;
+          if (total > 0 && onProgress) {
+            onProgress(received / total * 100);
+          }
+        });
+        res.on("error", async (err2) => {
+          out.destroy();
+          await cleanup();
+          reject(err2);
+        });
+        res.pipe(out);
+        out.on("finish", async () => {
+          out.close();
+          if (total > 0 && received !== total) {
+            await cleanup();
+            reject(new Error(`Downloaded ${received} bytes, expected ${total} \u2014 update download was truncated`));
+            return;
+          }
+          resolve();
+        });
+        out.on("error", async (err2) => {
+          await cleanup();
+          reject(err2);
+        });
+      });
+      req.on("error", async (err2) => {
+        await cleanup();
+        reject(err2);
+      });
+    };
+    attempt(url, 5);
+  });
+}
 
 // src/main/app/app.ts
 import { toDisposable as toDisposable8 } from "@dimina-kit/electron-deck/main";
@@ -11752,7 +12012,7 @@ async function disposeContext(ctx) {
 function createConfiguredMainWindow(config, rendererDir2) {
   const mainWindow = createMainWindow({
     title: config.appName ?? "Dimina DevTools",
-    indexHtml: path24.join(rendererDir2, "entries/main/index.html"),
+    indexHtml: path25.join(rendererDir2, "entries/main/index.html"),
     width: config.window?.width,
     height: config.window?.height,
     minWidth: config.window?.minWidth,
@@ -11865,7 +12125,7 @@ function enableDevRendererAutoReload(rendererDir2) {
     });
   }
   let reloadTimer = null;
-  const watcher = fs12.watch(rendererDir2, { recursive: true }, () => {
+  const watcher = fs13.watch(rendererDir2, { recursive: true }, () => {
     if (reloadTimer) clearTimeout(reloadTimer);
     reloadTimer = setTimeout(() => {
       for (const win of BrowserWindow8.getAllWindows()) {
@@ -11895,7 +12155,7 @@ function runDevtoolsBootstrap(config = {}) {
   } catch {
   }
 }
-async function createDevtoolsRuntime(config = {}) {
+async function createDevtoolsRuntime(config = {}, onInstanceCreated) {
   await app15.whenReady();
   applyTheme(loadWorkbenchSettings().theme);
   const rendererDir2 = config.rendererDir ?? rendererDir;
@@ -11924,6 +12184,7 @@ async function createDevtoolsRuntime(config = {}) {
     registerSimulatorApi: (name, handler) => context.registry.add(toDisposable8(context.simulatorApis.register(name, handler))),
     dispose: () => disposeContext(context)
   };
+  onInstanceCreated?.(instance);
   instance.registerSimulatorApi("login", async () => {
     return "hello";
   });
@@ -12036,8 +12297,8 @@ async function createDevtoolsRuntime(config = {}) {
       bridge: context.bridge
     }));
   }
-  const bundleDir = config.editorViewConfig?.bundleDir ?? path24.join(devtoolsPackageRoot, "dist/vscode-workbench");
-  if (!fs12.existsSync(path24.join(bundleDir, "index.html"))) {
+  const bundleDir = config.editorViewConfig?.bundleDir ?? path25.join(devtoolsPackageRoot, "dist/vscode-workbench");
+  if (!fs13.existsSync(path25.join(bundleDir, "index.html"))) {
     console.warn(
       `[workbench] editor bundle not found at ${bundleDir} \u2014 skipping embedded editor assembly`
     );
@@ -12074,6 +12335,7 @@ async function createDevtoolsRuntime(config = {}) {
 // src/main/runtime/devtools-backend.ts
 function createDevtoolsBackend(config = {}) {
   let instance = null;
+  let assembling = null;
   return {
     // The backend builds the devtools main window itself (framework skips its own).
     // Its only construction-time needs are the host preload + `sandbox:false`
@@ -12095,15 +12357,33 @@ function createDevtoolsBackend(config = {}) {
     // Setup (post-whenReady): app lifecycle (window-all-closed → quit) + the
     // full devtools assembly.
     assemble: async () => {
-      registerAppLifecycle();
-      instance = await createDevtoolsRuntime(config);
+      registerAppLifecycle(() => instance?.context.views.disposeAll());
+      assembling = createDevtoolsRuntime(config, (created) => {
+        instance = created;
+        if (isAppQuitting()) instance.context.views.disposeAll();
+      }).then(() => {
+      });
+      await assembling;
     },
     // Dispose the devtools context during the framework's deterministic shutdown
     // (app.on('will-quit') → shutdown() → runShutdownCleanup(), awaited once).
     // Without this, the compile session (a child process, torn down by
     // closeProject) and the IPC registry would leak on exit. The framework awaits
     // this hook, so teardown is no longer a best-effort before-quit reach-around.
-    onShutdown: () => instance?.dispose()
+    //
+    // Waits for `assembling` first: `instance` can be non-null (published
+    // early, above) while `createDevtoolsRuntime`'s own async body — the
+    // host's `onSetup` and everything scheduled after it — is still running
+    // and still adding entries to `instance.context.registry`. Disposing
+    // that registry out from under an in-flight assembly throws instead of
+    // tearing down cleanly (`DisposableRegistry.add` rejects post-dispose).
+    // `.catch()` here: assembly failing is `assemble`'s problem to surface,
+    // not a reason to skip disposing whatever DID get constructed.
+    onShutdown: async () => {
+      await assembling?.catch(() => {
+      });
+      await instance?.dispose();
+    }
   };
 }
 
@@ -12113,7 +12393,18 @@ function launch(config = {}) {
 }
 
 // src/main/index.ts
-launch().catch((err2) => {
+var updateChecker = app16.isPackaged && !app16.getVersion().includes("-dev.") ? createGitHubReleaseChecker({
+  owner: "EchoTechFE",
+  repo: "dimina-kit",
+  parseVersion: (release) => {
+    for (const asset of release.assets) {
+      const match = /^dimina-devtools-(\d+\.\d+\.\d+)-/.exec(asset.name);
+      if (match) return match[1];
+    }
+    return null;
+  }
+}) : void 0;
+launch({ updateChecker }).catch((err2) => {
   console.error("[devtools] fatal: launch() failed during boot", err2);
   app16.exit(1);
 });

package/dist/main/index.js

@@ -1,10 +1,58 @@
 import { app } from 'electron';
 import { launch } from './app/launch.js';
+import { createGitHubReleaseChecker } from './services/update/index.js';
+// Only a packaged RELEASE-channel build self-updates against this repo's
+// GitHub Releases:
+// - `pnpm dev` runs stay quiet (no API calls, no update dialog) — same
+//   app.isPackaged gate used elsewhere for dev-only behavior.
+// - A packaged DEV-channel build (release.yml's `channel: dev` — distributed
+//   only as a 30-day Actions artifact for QA/branch testing, never a GitHub
+//   Release) must NOT get this either: release.yml's dev channel never
+//   creates a GitHub Release, so /releases/latest always reflects the
+//   RELEASE channel — a dev build would be prompted to "update" to an
+//   unrelated stable build, and clicking it would silently swap out the
+//   very branch/PR build the person downloaded it to test. dev-channel
+//   versions always carry bump-dev-version.js's `-dev.<timestamp>` suffix;
+//   release-channel versions never do — use that as the channel signal.
+// - Hosts that embed devtools via `launch(config)` supply their own
+//   `updateChecker` (or none) and are unaffected — this default only
+//   applies to this entry point.
+//
+// Custom parseVersion, NOT the default asset-name fallback and NOT
+// 'trailing-number':
+// - release.yml's GitHub Release tag (`release-YYYYMMDD-N`) is an unrelated
+//   release-sequence label, not this app's version — 'trailing-number' would
+//   compare its bare counter against app.getVersion() (e.g. "0.4.0")
+//   numerically, which looks "newer" once the counter passes the app's major
+//   version, reporting an update on every single check forever.
+// - The built-in asset-name fallback (defaultParseVersion's SEMVER_RE) finds
+//   the version inside `dimina-devtools-0.4.0-mac-arm64.dmg` (see release.yml's
+//   "Rename macOS dmg" / Archive steps) but its optional prerelease-suffix
+//   capture greedily swallows the trailing `-mac-arm64.dmg` as a "prerelease"
+//   tag, so the update dialog would show a garbled "0.5.0-mac-arm64.dmg".
+//   Extract just the clean `x.y.z` from our own known asset naming instead.
+// Short-circuited: app.getVersion() must only be read once isPackaged is
+// already known true, both because it's meaningless before then and because
+// some minimal test/dev electron mocks don't stub getVersion() at all.
+const updateChecker = app.isPackaged && !app.getVersion().includes('-dev.')
+    ? createGitHubReleaseChecker({
+        owner: 'EchoTechFE',
+        repo: 'dimina-kit',
+        parseVersion: (release) => {
+            for (const asset of release.assets) {
+                const match = /^dimina-devtools-(\d+\.\d+\.\d+)-/.exec(asset.name);
+                if (match)
+                    return match[1];
+            }
+            return null;
+        },
+    })
+    : undefined;
 // Fire-and-forget boot: launch() returns the electron-deck whenReady gate
 // promise. A bare call would let a boot failure escape as an unhandledRejection
 // (no diagnostics, can be swallowed). Surface it via a structured failure exit:
 // log the cause and exit non-zero (per workbench-model.md fire-and-forget rule).
-launch().catch((err) => {
+launch({ updateChecker }).catch((err) => {
     console.error('[devtools] fatal: launch() failed during boot', err);
     app.exit(1);
 });