@dimina-kit/devtools 0.4.0 → 0.5.0-dev.20260908120530

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

@@ -1,9 +1,11 @@
 import { app, shell } from 'electron';
-import { UpdateChannel } from '../../../shared/ipc-channels.js';
+import { UpdateChannel } from '../../../shared/ipc-channels-overlays.js';
 import { IpcRegistry } from '../../utils/ipc-registry.js';
 export class UpdateManager {
     checker;
-    mainWindow;
+    showUpdatePanel;
+    notifyDownloadProgress;
+    hideUpdatePanel;
     getCurrentVersion;
     latestUpdate = null;
     downloadedPath = null;
@@ -20,9 +22,19 @@ export class UpdateManager {
     timer = null;
     initialTimer = null;
     ipc;
+    /**
+     * Set by `dispose()`. Clearing the timers only stops FUTURE ticks — an
+     * in-flight `checkAndNotify()` invocation (already past its `await
+     * this.check()`) has no timer left to cancel it, and would otherwise call
+     * `showUpdatePanel` after dispose has torn down the overlay panel that
+     * owns (e.g. `views.disposeAll()` destroying its WebContentsView).
+     */
+    disposed = false;
     constructor(opts) {
         this.checker = opts.checker;
-        this.mainWindow = opts.mainWindow;
+        this.showUpdatePanel = opts.showUpdatePanel;
+        this.notifyDownloadProgress = opts.notifyDownloadProgress;
+        this.hideUpdatePanel = opts.hideUpdatePanel;
         this.getCurrentVersion = opts.getCurrentVersion ?? (() => app.getVersion());
         this.ipc = new IpcRegistry(opts.senderPolicy);
         this.registerIpc();
@@ -32,15 +44,29 @@ export class UpdateManager {
         this.ipc
             .handle(UpdateChannel.Check, async () => this.check())
             .handle(UpdateChannel.Download, async () => this.download())
-            .handle(UpdateChannel.Install, async () => this.install());
+            .handle(UpdateChannel.Install, async () => this.install())
+            .on(UpdateChannel.Close, () => this.hideUpdatePanel());
     }
     async check() {
         try {
             const currentVersion = this.getCurrentVersion();
             const info = await this.checker.checkForUpdates(currentVersion);
             if (info) {
+                // The periodic timer re-runs check() forever (see startPeriodicCheck),
+                // including after the user already downloaded this same update but
+                // before they clicked Install. Only invalidate downloadedPath when the
+                // update identity actually changed — unconditionally nulling it here
+                // would silently no-op a later install() (it's a bare `if (this.downloadedPath)`)
+                // for anyone who takes longer than one check interval to act. Compare
+                // downloadUrl too, not just version: a re-uploaded/replaced asset can
+                // keep the same version string under a different URL, and reusing the
+                // stale downloadedPath would then install bytes that were never
+                // actually verified against this checkForUpdates() result.
+                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 };
@@ -56,7 +82,7 @@ export class UpdateManager {
         }
         try {
             const filePath = await this.checker.downloadUpdate(this.latestUpdate, (percent) => {
-                this.mainWindow.webContents.send(UpdateChannel.DownloadProgress, { percent });
+                this.notifyDownloadProgress(percent);
             });
             this.downloadedPath = filePath;
             return { success: true, filePath };
@@ -66,11 +92,23 @@ export class UpdateManager {
             return { success: false, error: String(err) };
         }
     }
-    install() {
-        if (this.downloadedPath) {
-            shell.openPath(this.downloadedPath);
-            app.quit();
+    async install() {
+        if (!this.downloadedPath) {
+            return { success: false, error: 'No update downloaded' };
         }
+        // shell.openPath() resolves (never rejects) with an empty string on
+        // success or an error message on failure — it was previously fired
+        // fire-and-forget immediately followed by app.quit(), so a failure (e.g.
+        // no application associated with the installer) silently closed the app
+        // without ever launching the installer, and the renderer had no way to
+        // know anything went wrong.
+        const failure = await shell.openPath(this.downloadedPath);
+        if (failure) {
+            console.warn('[UpdateManager] install failed:', failure);
+            return { success: false, error: failure };
+        }
+        app.quit();
+        return { success: true };
     }
     /**
      * Tear down timers + IPC handlers. Returns a Promise so callers that need
@@ -79,6 +117,7 @@ export class UpdateManager {
      * the timer clears + handler removals are scheduled synchronously.
      */
     dispose() {
+        this.disposed = true;
         if (this.timer) {
             clearInterval(this.timer);
             this.timer = null;
@@ -95,12 +134,17 @@ export class UpdateManager {
     }
     async checkAndNotify() {
         const result = await this.check();
+        // dispose() only cancels the timers that SCHEDULE future ticks — a tick
+        // already in flight (past this await) has nothing left to cancel it, and
+        // must not call into a torn-down panel/registry after the fact.
+        if (this.disposed)
+            return;
         if (!result.hasUpdate || !result.info)
             return;
         if (this.hasNotified)
             return;
         this.hasNotified = true;
-        this.mainWindow.webContents.send(UpdateChannel.Available, result.info);
+        this.showUpdatePanel(result.info);
     }
 }
 //# sourceMappingURL=update-manager.js.map

package/dist/main/services/views/clear-console-filter.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export declare function buildClearConsoleFilterScript(): string;
+//# sourceMappingURL=clear-console-filter.d.ts.map

package/dist/main/services/views/clear-console-filter.js

@@ -0,0 +1,86 @@
+/**
+ * Clears the right-panel Console panel's text-filter box on a FRESH project
+ * open, together with the stale persisted keys behind it.
+ *
+ * ── Why this exists ──────────────────────────────────────────────────────
+ * The Console filter text is a DevTools-owned setting that DevTools itself
+ * persists: it lives on the `devtools://` origin's localStorage, backed by the
+ * default session's on-disk storage (verified on disk:
+ * `~/Library/Application Support/Dimina DevTools/Local Storage/leveldb` holds a
+ * `console.textFilter` entry). An earlier implementation of the internal-log
+ * hiding wrote `-/^\[service\]/`-style negative filters straight into the box
+ * (see console-filter.ts's header for that history); that value still sits in
+ * localStorage and is restored on every project reopen / app restart. We do NOT
+ * fight DevTools' persistence mechanism here — instead, on each fresh project
+ * open we remove the stale keys and reset the visible box, so a project starts
+ * with the developer's own filter surface genuinely empty.
+ *
+ * ── When it runs ─────────────────────────────────────────────────────────
+ * Only the PROJECT-OPEN path arms this (see native-simulator-devtools-host.ts:
+ * `attach()` sets the flag; the injection consumes it once). Service-host pool
+ * swaps (hot-reload respawn) rebuild the front-end host too, but deliberately do
+ * NOT clear — the developer may legitimately have typed a filter during the
+ * session and a respawn must not drop in-flight work.
+ *
+ * ── Discipline (mirrors console-filter.ts) ────────────────────────────────
+ * In-realm bootstrap probe before touching `Console.ConsoleView.instance()` (an
+ * early construction transitively creates IssuesManager and permanently kills
+ * the front-end's own bootstrap — see frontend-bootstrap-gate.ts); bounded
+ * retry; silent degradation on any failure. The main process additionally holds
+ * this whole injection behind `whenFrontendBootstrapped`.
+ */
+/**
+ * Build the `executeJavaScript` source that clears the Console filter box.
+ *
+ * Two levers, belt-and-suspenders:
+ *   1. remove the stale persisted keys (`console.textFilter` — the on-disk
+ *      leftover we actually observed, and its kebab-case sibling) so a Console
+ *      view constructed after this script reads an empty setting;
+ *   2. reset the already-constructed panel's visible box via
+ *      `filter.textFilterUI.setValue('')`, which persists the empty value back
+ *      through the panel's own setting path.
+ */
+export function buildClearConsoleFilterScript() {
+    return `(function(){
+    var attempts = 0;
+    var MAX = 100;
+    function bootstrapReady() {
+      try {
+        var eui = globalThis.EUI;
+        if (!eui || !eui.ShortcutRegistry || !eui.ShortcutRegistry.ShortcutRegistry) return false;
+        eui.ShortcutRegistry.ShortcutRegistry.instance();
+        return true;
+      } catch (_) { return false; }
+    }
+    function tryClear() {
+      attempts++;
+      var scheduleRetry = attempts < MAX;
+      if (!bootstrapReady()) {
+        if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+        return;
+      }
+      try {
+        try { localStorage.removeItem('console.textFilter'); } catch(_) {}
+        try { localStorage.removeItem('console.text-filter'); } catch(_) {}
+        var ConsoleNS = globalThis.Console;
+        var view = ConsoleNS && ConsoleNS.ConsoleView ? ConsoleNS.ConsoleView.instance() : null;
+        var f = view ? view.filter : null;
+        var box = f && f.textFilterUI;
+        if (!box || typeof box.setValue !== 'function' || typeof box.value !== 'function') {
+          if (scheduleRetry) { setTimeout(tryClear, 100); return; }
+          return;
+        }
+        var current = box.value();
+        if (current) {
+          box.setValue('');
+          if (typeof f.updateCurrentFilter === 'function') f.updateCurrentFilter();
+          if (typeof f.onFilterChanged === 'function') f.onFilterChanged();
+        }
+      } catch(_) {
+        if (scheduleRetry) setTimeout(tryClear, 100);
+      }
+    }
+    tryClear();
+  })()`;
+}
+//# sourceMappingURL=clear-console-filter.js.map

package/dist/main/services/views/console-filter-test-fixtures.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { type Mock } from 'vitest';
+export interface FakeViewMessage {
+    consoleMessage: () => {
+        messageText: string;
+    };
+}
+export type ShouldBeVisible = (this: unknown, viewMessage: FakeViewMessage) => boolean;
+export interface FakeConsoleFilterClass {
+    original: Mock<ShouldBeVisible>;
+    prototype: {
+        shouldBeVisible?: ShouldBeVisible;
+    };
+    newInstance: () => {
+        shouldBeVisible: ShouldBeVisible;
+    };
+}
+export interface FakeConsoleView {
+    view: {
+        filter: {
+            currentFilter: object;
+            textFilterUI: {
+                value: () => string;
+                setValue: Mock<(next: string) => void>;
+            };
+        };
+        onFilterChanged: Mock<() => void>;
+    };
+    setValue: Mock<(next: string) => void>;
+    onFilterChanged: Mock<() => void>;
+    filterText: () => string;
+}
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export declare function createViewMessage(messageText: string): FakeViewMessage;
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export declare function createConsoleFilterClass(verdict?: boolean | ShouldBeVisible): FakeConsoleFilterClass;
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export declare function createConsoleFilterClassWithoutHook(): {
+    prototype: Record<string, unknown>;
+    newInstance: () => object;
+};
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export declare function createConsoleView(currentFilter: object, initialFilterText?: string): FakeConsoleView;
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export declare function createReadyEui(): {
+    ShortcutRegistry: {
+        ShortcutRegistry: {
+            instance: () => {};
+        };
+    };
+};
+export declare function createGlobalThis(view: unknown): {
+    EUI: {
+        ShortcutRegistry: {
+            ShortcutRegistry: {
+                instance: () => {};
+            };
+        };
+    };
+    Console: {
+        ConsoleView: {
+            instance: () => unknown;
+        };
+    };
+};
+export declare function run(script: string, fakeGlobalThis: object): void;
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export declare function recordWarnings(): {
+    messages: string[];
+};
+//# sourceMappingURL=console-filter-test-fixtures.d.ts.map

package/dist/main/services/views/console-filter-test-fixtures.js

@@ -0,0 +1,82 @@
+/**
+ * Fakes shaped like the Chrome DevTools front-end objects
+ * `buildInternalLogHideScript()`'s generated source talks to, shared by
+ * console-filter.test.ts (what the hook does) and
+ * console-filter-degradation.test.ts (what happens when the panel is not there
+ * or the front-end API has moved).
+ *
+ * These are STUBS OF A FOREIGN API, not a second implementation: every test
+ * runs the real generated script string through `new Function`, so the fakes
+ * only have to expose the handful of members the script reaches for. What they
+ * cannot prove is that the real front-end still has those members — that is
+ * e2e/console-filter-live.spec.ts's job.
+ */
+import { vi } from 'vitest';
+/** A ConsoleViewMessage stub exposing the single field the hook inspects. */
+export function createViewMessage(messageText) {
+    return { consoleMessage: () => ({ messageText }) };
+}
+/**
+ * A ConsoleFilter "class": one shared prototype carrying `shouldBeVisible`,
+ * plus a factory for further instances off that same prototype — what
+ * `ConsoleFilter.clone()` produces. `original` is the pre-existing
+ * implementation the hook must delegate to.
+ */
+export function createConsoleFilterClass(verdict = true) {
+    const impl = typeof verdict === 'function' ? verdict : () => verdict;
+    const original = vi.fn(impl);
+    const prototype = { shouldBeVisible: original };
+    return {
+        original,
+        prototype,
+        newInstance: () => Object.create(prototype),
+    };
+}
+/** A ConsoleFilter whose prototype chain carries no `shouldBeVisible` at all. */
+export function createConsoleFilterClassWithoutHook() {
+    const prototype = Object.create(null);
+    return { prototype, newInstance: () => Object.create(prototype) };
+}
+/** The ConsoleView surface the script reaches through: filter + refresh entry point. */
+export function createConsoleView(currentFilter, initialFilterText = '') {
+    let filterText = initialFilterText;
+    const setValue = vi.fn((next) => { filterText = next; });
+    const onFilterChanged = vi.fn();
+    return {
+        view: {
+            filter: {
+                currentFilter,
+                textFilterUI: { value: () => filterText, setValue },
+            },
+            onFilterChanged,
+        },
+        setValue,
+        onFilterChanged,
+        filterText: () => filterText,
+    };
+}
+/** A front end whose bootstrap has finished: the probe returns instead of throwing. */
+export function createReadyEui() {
+    return { ShortcutRegistry: { ShortcutRegistry: { instance: () => ({}) } } };
+}
+export function createGlobalThis(view) {
+    return { EUI: createReadyEui(), Console: { ConsoleView: { instance: () => view } } };
+}
+export function run(script, fakeGlobalThis) {
+    new Function('globalThis', script)(fakeGlobalThis);
+}
+/**
+ * Collect `console.warn` output as plain strings for the whole test file.
+ *
+ * Reading `warnSpy.mock.calls` instead would hand every assertion an untyped
+ * `any[]`; the degradation tests care about WHICH warning was emitted, so the
+ * text has to survive into the assertion with its type intact.
+ */
+export function recordWarnings() {
+    const record = { messages: [] };
+    vi.spyOn(console, 'warn').mockImplementation((...args) => {
+        record.messages.push(args.map((arg) => String(arg)).join(' '));
+    });
+    return record;
+}
+//# sourceMappingURL=console-filter-test-fixtures.js.map

package/dist/main/services/views/console-filter.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Hides dimina framework internal log lines from the right-panel
+ * (user-facing) Console, WITHOUT occupying the panel's visible text-filter
+ * box (see console-forward/internal-log.ts for the prefix judge this
+ * mirrors). The framework prints these via a plain `console.log` call INSIDE
+ * the inspected service host itself; main has no interception point for a
+ * native console line (see console-forward/index.ts's header comment), so the
+ * lever has to live inside the front-end.
+ *
+ * ── Why not the text-filter box ──────────────────────────────────────────
+ * Writing `-/^\[service\]/` into the Console's filter input does hide the
+ * lines, but the string then sits in the box the developer uses for their own
+ * filtering: it looks like something they typed, it silently comes back after
+ * every re-point (an empty box is indistinguishable from "never set", so
+ * clearing it just invites the next injection to rewrite it), and it consumes
+ * the one filter slot the panel offers. Driving the panel's own visibility
+ * judge instead leaves the box genuinely empty and under the developer's sole
+ * control.
+ *
+ * ── Mechanism ────────────────────────────────────────────────────────────
+ * `Console.ConsoleView.instance().filter.currentFilter` is the ConsoleFilter
+ * object the panel consults for every message, through its prototype method
+ * `shouldBeVisible(viewMessage)`. Wrapping that PROTOTYPE method (not the
+ * instance) rejects internal-log lines ahead of the panel's normal logic:
+ *   - `currentFilter` is not the only ConsoleFilter the panel judges with:
+ *     `ConsoleFilter.clone()` returns `new ConsoleFilter(...)`, and the
+ *     sidebar filters through those clones. They share the prototype, so one
+ *     patch covers all of them — and keeps covering them if the panel ever
+ *     replaces `currentFilter` outright. (Editing the filter box does NOT
+ *     replace it today: `ConsoleViewFilter` builds `currentFilter` once in its
+ *     constructor and `updateCurrentFilter()` mutates that same instance's
+ *     `parsedFilters` / `levelsMask` / `executionContext` in place.)
+ *   - The wrapper delegates to the original for everything else, so a
+ *     developer's own filter keeps working exactly as before — this only ever
+ *     subtracts internal-log lines.
+ * Verified end-to-end against the real bundled front-end
+ * (e2e/console-filter-live.spec.ts): filter box reads empty, a `[service]`
+ * line logged afterwards stays hidden, an ordinary business log stays visible.
+ *
+ * This patches only the realm of the wc it is injected into — the right-panel
+ * front-end. The standalone floating debug window is a separate front-end with
+ * its own realm, and its content arrives by a different route entirely
+ * (main-side CDP capture → console-forward → global-console-mirror, which is
+ * deliberately UNFILTERED), so framework internals stay fully visible there.
+ * That window is the escape hatch for anyone who needs to read them.
+ *
+ * ── Timing ───────────────────────────────────────────────────────────────
+ * `Console.ConsoleView` has no lifecycle EVENT marking "fully constructed" —
+ * only the checkable condition of whether `.instance()` and the reach into
+ * `.filter.currentFilter` throw. The injection therefore retries on a bounded
+ * interval (see `LIVE_FILTER_POLL_MAX_ATTEMPTS`/`_INTERVAL_MS`) rather than
+ * guessing a fixed delay, and stops as soon as the wrapper is installed.
+ *
+ * Every tick gates on the front-end bootstrap probe BEFORE touching
+ * `ConsoleView.instance()`: an early construction transitively creates
+ * IssuesManager and permanently kills the front-end's own bootstrap
+ * (`ensureFirst` conflict in MainImpl.#createAppUI) — see
+ * frontend-bootstrap-gate.ts for the full mechanism. The main process
+ * additionally holds this whole injection behind `whenFrontendBootstrapped`;
+ * the in-realm probe is defense in depth for any other caller.
+ */
+/**
+ * First-arg prefix marking a dimina SERVICE-layer framework log. A line counts
+ * as internal when its text IS this tag or starts with the tag plus a space —
+ * the same shape console-forward/internal-log.ts requires of the first arg, so
+ * a business line like '[service]业务状态' stays visible on both sides.
+ * These entries are captured
+ * directly by the native CDP `Runtime.consoleAPICalled` attach on the service
+ * host (service-host/preload.cjs deliberately does not monkeypatch
+ * `console.*` there — see its header comment — so there is no main-owned code
+ * between the framework's call and the attached DevTools), which is why the
+ * front-end is the only place they can be hidden.
+ *
+ * RENDER-layer framework noise (`[system]`) needs nothing here:
+ * `console-forward/index.ts`'s `forwardRenderToServiceHost` gates on
+ * `isInternalLogMessage` and never injects those entries into the service
+ * host's console at all — filtered at the source, in main-owned code.
+ */
+export declare const INTERNAL_LOG_HIDDEN_PREFIX = "[service]";
+/** Marker property stamped on the patched prototype, so a re-point re-running
+ *  this script wraps once rather than nesting a wrapper per injection. Also
+ *  the signal e2e specs read to tell "wrapper installed" from "not yet". */
+export declare const INTERNAL_LOG_WRAPPER_MARK = "__diminaInternalLogHidden";
+/**
+ * Build the `executeJavaScript` source that installs the internal-log
+ * visibility wrapper described in this module's header comment.
+ *
+ * Failure is loud but non-fatal: a front-end whose ConsoleFilter prototype has
+ * no `shouldBeVisible` (a future Chromium reshuffle) warns once and gives up
+ * rather than retrying a structurally absent surface — the panel then simply
+ * shows framework lines, which is the pre-existing behavior, not a breakage.
+ */
+export declare function buildInternalLogHideScript(hiddenPrefix?: string): string;
+//# sourceMappingURL=console-filter.d.ts.map