@dimina-kit/devtools 0.4.0 → 0.5.0

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);
 });

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

@@ -1,32 +1,2 @@
-/**
- * Per-app-session registry for the app-level lifecycle listeners registered
- * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
- * (and their `off*` removers).
- *
- * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
- * persistent callback id in `params.success` (service `callback.store(fn,
- * keep=true)`), so the router stores the id here and re-fires it via
- * `sendCallback` on every app foreground / background / error.
- *
- * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
- * `callback.store` dedups by function and returns the original evtId, so `off*`
- * carries that id and removes exactly that listener. `wx.offAppShow()` with no
- * argument carries no id and clears every listener of the event (WeChat
- * contract).
- */
-export type AppLifecycleEvent = 'onAppShow' | 'onAppHide' | 'onError';
-export interface AppLifecycleController {
-    /** Store a keep callback id for an event. Null/undefined ids are ignored. */
-    register(appSessionId: string, event: AppLifecycleEvent, callbackId: unknown): void;
-    /**
-     * Remove a listener. With `callbackId`, removes only that id; without one,
-     * clears every listener of the event for the session.
-     */
-    unregister(appSessionId: string, event: AppLifecycleEvent, callbackId?: unknown): void;
-    /** Snapshot of the registered callback ids (empty for unknown session/event). */
-    listeners(appSessionId: string, event: AppLifecycleEvent): unknown[];
-    /** Drop all listeners for a torn-down session. */
-    dispose(appSessionId: string): void;
-}
-export declare function createAppLifecycleController(): AppLifecycleController;
+export * from '@dimina-kit/electron-runtime/main/app-lifecycle';
 //# sourceMappingURL=app-lifecycle.d.ts.map

package/dist/main/ipc/app-lifecycle.js

@@ -1,54 +1,2 @@
-/**
- * Per-app-session registry for the app-level lifecycle listeners registered
- * from the mini-program service layer: `wx.onAppShow` / `onAppHide` / `onError`
- * (and their `off*` removers).
- *
- * These arrive as keep subscriptions — `wx.onAppShow(cb)` encodes `cb` as a
- * persistent callback id in `params.success` (service `callback.store(fn,
- * keep=true)`), so the router stores the id here and re-fires it via
- * `sendCallback` on every app foreground / background / error.
- *
- * `wx.offAppShow(cb)` re-encodes the SAME `cb`: with `keep=true`,
- * `callback.store` dedups by function and returns the original evtId, so `off*`
- * carries that id and removes exactly that listener. `wx.offAppShow()` with no
- * argument carries no id and clears every listener of the event (WeChat
- * contract).
- */
-export function createAppLifecycleController() {
-    const sessions = new Map();
-    return {
-        register(appSessionId, event, callbackId) {
-            if (callbackId === undefined || callbackId === null)
-                return;
-            let events = sessions.get(appSessionId);
-            if (!events) {
-                events = new Map();
-                sessions.set(appSessionId, events);
-            }
-            let ids = events.get(event);
-            if (!ids) {
-                ids = new Set();
-                events.set(event, ids);
-            }
-            ids.add(callbackId);
-        },
-        unregister(appSessionId, event, callbackId) {
-            const events = sessions.get(appSessionId);
-            if (!events)
-                return;
-            if (callbackId === undefined || callbackId === null) {
-                events.delete(event);
-                return;
-            }
-            events.get(event)?.delete(callbackId);
-        },
-        listeners(appSessionId, event) {
-            const ids = sessions.get(appSessionId)?.get(event);
-            return ids ? Array.from(ids) : [];
-        },
-        dispose(appSessionId) {
-            sessions.delete(appSessionId);
-        },
-    };
-}
+export * from '@dimina-kit/electron-runtime/main/app-lifecycle';
 //# sourceMappingURL=app-lifecycle.js.map

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

@@ -1,4 +1,7 @@
 import type { WorkbenchContext } from '../services/workbench-context.js';
 import type { Disposable } from '@dimina-kit/electron-deck/main';
-export declare function registerAppIpc(ctx: Pick<WorkbenchContext, 'brandingProvider' | 'appName' | 'senderPolicy'>): Disposable;
+import { type IpcInput } from '../utils/ipc-context-source.js';
+type AppIpcCtx = Pick<WorkbenchContext, 'brandingProvider' | 'appName' | 'senderPolicy'>;
+export declare function registerAppIpc(input: IpcInput<AppIpcCtx>): Disposable;
+export {};
 //# sourceMappingURL=app.d.ts.map

package/dist/main/ipc/app.js

@@ -1,8 +1,9 @@
 import { AppChannel } from '../../shared/ipc-channels.js';
 import { IpcRegistry } from '../utils/ipc-registry.js';
-export function registerAppIpc(ctx) {
-    return new IpcRegistry(ctx.senderPolicy)
-        .handle(AppChannel.GetBranding, async () => {
+import { toIpcContextSource } from '../utils/ipc-context-source.js';
+export function registerAppIpc(input) {
+    return new IpcRegistry(toIpcContextSource(input))
+        .handleRouted(AppChannel.GetBranding, async (ctx) => {
         if (ctx.brandingProvider)
             return ctx.brandingProvider();
         return { appName: ctx.appName };

package/dist/main/ipc/bridge-router.d.ts

@@ -1,119 +1,22 @@
-import type { WebContents } from 'electron';
-import type { NativeDeviceInfo } from '../../shared/ipc-channels.js';
-import type { PageStackEntry } from '../../shared/bridge-channels.js';
-import type { WorkbenchContext } from '../services/workbench-context.js';
-import type { DebugTap } from '@dimina-kit/electron-deck/main';
+export * from '@dimina-kit/electron-runtime/main/bridge-router';
+import { type RuntimeContext, type RuntimeEvents } from '@dimina-kit/electron-runtime/main/runtime-context';
+import type { SessionRuntimeStatus, SyncStorageChange } from '@dimina-kit/electron-runtime';
+import type { MessageEnvelope } from '../../shared/bridge-channels.js';
+type DevtoolsBridgeContext = Omit<RuntimeContext, 'events'> & {
+    events?: RuntimeEvents;
+    notify?: {
+        sessionRuntimeStatus(payload: SessionRuntimeStatus): void;
+    };
+    appData?: {
+        evictBridge(appId: string, bridgeId: string): void;
+        onServiceToRender(appId: string, message: MessageEnvelope): void;
+    };
+    onServiceStorageChanged?: (appId: string, change: SyncStorageChange) => void;
+};
 /**
- * Watchdog window a spawned session gets to reach `'running'` (root page
- * `domReady`) before `handleSpawn`'s launch timer reports `'launch-failed'`
- * with `code: 'timeout'`. Exported so tests can assert against the real
- * constant instead of a magic number.
+ * DevTools compatibility assembly. New contexts already own RuntimeEvents;
+ * narrow historical test/downstream contexts are upgraded here so the runtime
+ * package itself stays unaware of panels and renderer notifications.
  */
-export declare const LAUNCH_TIMEOUT_MS = 20000;
-/** Default timeout for a simulator-forwarded API call. */
-/**
- * Accessor over the bridge-router's private `RouterState`, stashed on
- * `ctx.bridge` so other main-process services (simulator-storage, automation,
- * appdata) can resolve live WebContents handles without owning router state.
- * All getters resolve fresh each call (the pre-warm pool can swap windows on
- * respawn, so cached handles go stale).
- */
-/**
- * Render-side activity worth re-reading panel data on: a page's DOM mounted
- * (`domReady`), the visible page changed (`activePage`), or the active page's
- * DOM mutated in place (`domMutated`, from the render-guest MutationObserver).
- * Panels that pull from the active render guest (WXML/element-inspect) subscribe
- * via `BridgeRouterHandle.onRenderEvent` so they can refresh without polling.
- */
-export interface RenderEvent {
-    kind: 'domReady' | 'activePage' | 'domMutated';
-    appId: string;
-    bridgeId: string;
-    /** activePage only: the now-visible page's route (bare pagePath), if known.
-     * Lets the current-page panel push the route without a separate lookup. */
-    pagePath?: string;
-}
-/**
- * Point-in-time counts of every resource class RouterState owns. Leak coverage
- * (unit + e2e) asserts EXACT equality of this ledger around a churn cycle —
- * coarse memory sampling cannot see a leaked listener or a stale map entry, so
- * the owner of the bookkeeping reports precise counts instead.
- */
-export interface BridgeResourceCensus {
-    appSessions: number;
-    pageSessions: number;
-    serviceWcBindings: number;
-    /** Distinct live simulator webContents currently hosting ≥1 session. */
-    simulatorWcs: number;
-    /** Total session memberships across all simulator wcs. */
-    simulatorWcBindings: number;
-    renderWcBindings: number;
-    pendingApiCalls: number;
-    /**
-     * `listenerCount('destroyed')` per unique live simulator wc (keyed by wc id).
-     * One teardown hook per live session — a count above the hosted-session count
-     * is the one-dead-listener-per-soft-reload leak class.
-     */
-    simulatorDestroyedListeners: Record<number, number>;
-}
-export interface BridgeRouterHandle {
-    /** Whether native-host mode is on (main is the source of truth). */
-    isNativeHost(): boolean;
-    /** The render-host `<webview>` WebContents for a page bridgeId, or null. */
-    resolveRenderWc(bridgeId: string): WebContents | null;
-    /** The hidden service-host window WebContents for the active (or named) app. */
-    getServiceWc(appId?: string): WebContents | null;
-    /** The service-host window WebContents for the app that owns a page bridgeId,
-     * or null. Lets render-side consumers (console forwarder) target the matching
-     * app's service host even with multiple sessions open. */
-    getServiceWcForBridge(bridgeId: string): WebContents | null;
-    /** The visible page's render WebContents for the active (or named) app. */
-    getActiveRenderWc(appId?: string): WebContents | null;
-    /** The visible top-of-stack page bridgeId for the active (or named) app. */
-    getActiveBridgeId(appId?: string): string | null;
-    /** The full ordered page stack (bottom→top) reported by DeviceShell, or null
-     * before the first PAGE_STACK signal. Optional: only the native-host bridge
-     * provides it (the default path derives the stack from the simulator URL). */
-    getPageStack?(appId?: string): PageStackEntry[] | null;
-    /** Subscribe to render-side activity (domReady / active-page change). */
-    onRenderEvent(listener: (event: RenderEvent) => void): () => void;
-    /** The currently-selected device (renderer toolbar), or null pre-selection. */
-    getDevice(): NativeDeviceInfo | null;
-    /** Cache the selected device + push DEVICE_CHANGE to the live simulator WC(s). */
-    setDevice(device: NativeDeviceInfo): void;
-    /**
-     * Deterministically tear down every app session bound to the given simulator
-     * WebContentsView id (project close / DeviceShell respawn). The session
-     * mappings are cleared, the render-host guest webContents are closed, and the
-     * service-host window is closed/released — synchronously, instead of waiting
-     * on the WCV's async `'destroyed'` cascade — so the next project never
-     * re-resolves or screenshots the outgoing project's render guest. Idempotent
-     * with the `simulatorWc.once('destroyed')` hook (`disposeAppSession`
-     * early-returns once a session is gone). Optional so partial test mocks of the
-     * handle need not stub it.
-     *
-     * The synchronous prefix of the underlying disposeAppSession clears every map
-     * + closes the render guests + the service window before it awaits, so the
-     * bridge is clean the moment this is called. The returned promise resolves
-     * after the async tail (pool.release / resourceServer.close) so the lifecycle
-     * owner can sequence a reopen after full teardown. NOTE: disposeAppSession
-     * catches and logs pool/resource-release failures internally, so the promise
-     * resolves rather than rejecting on those — it is a completion signal, not an
-     * error channel.
-     */
-    disposeSessionsForSimulator?(simulatorWcId: number): Promise<void>;
-    /**
-     * The router's resource ledger (see BridgeResourceCensus). Optional so the
-     * many partial BridgeRouterHandle test mocks don't each have to stub it.
-     */
-    census?(): BridgeResourceCensus;
-    /**
-     * The flag-gated debugTap (§7) over the bridge message stream. Exposed so a
-     * hidden devtools panel / automation can read `.entries()` when
-     * `DIMINA_DEBUG_TAP=1`; a no-op snapshot otherwise. Optional so the many
-     * partial `BridgeRouterHandle` test mocks don't each have to stub it.
-     */
-    debugTap?: DebugTap;
-}
-export declare function installBridgeRouter(ctx: WorkbenchContext): void;
+export declare function installBridgeRouter(ctx: DevtoolsBridgeContext): void;
 //# sourceMappingURL=bridge-router.d.ts.map