@dimina-kit/devtools 0.4.0 → 0.5.0

package/dist/main/services/workspace/rebuild-status.js

@@ -0,0 +1,36 @@
+/**
+ * Decide and emit the post-rebuild status for one completed rebuild.
+ *
+ * Explicit rebuild (`info.explicit` — the 重新编译 button, via
+ * `session.rebuild()`): the renderer's own relaunch drives a hard re-attach
+ * once the rebuild IPC resolves, and that re-attach is the run's ONLY
+ * reflection. Emitting `hotReload: true` here as well would race a soft
+ * reload against it — the two arrive through different channels with no
+ * ordering guarantee, so the soft reload can land AFTER the hard re-attach
+ * and drag the simulator back to the drifted page. The style fast path is a
+ * soft-update path too and is skipped for the same reason.
+ *
+ * Watcher rebuild (explicit absent/false) — style-only fast path: hot-swap the
+ * render-host stylesheets in place instead of respawning the DeviceShell —
+ * page stack / form state / scroll / focus survive (no jitter, no focus
+ * steal); `hotReload: false` keeps the renderer from bumping its reload token
+ * (the respawn signal). Falls through to the full reload when the swap can't
+ * run (no live render guest yet) so an edit is never dropped.
+ *
+ * `getProjectPages` never throws; empty pages are withheld so the renderer
+ * keeps its previous launch dropdown.
+ */
+export function reportRebuildStatus(info, deps) {
+    const { pages } = deps.repo.getProjectPages(deps.projectPath);
+    const pageList = pages.length ? pages : undefined;
+    if (info?.explicit) {
+        deps.sendStatus('ready', '编译完成', false, pageList);
+        return;
+    }
+    if (info?.styleOnly && deps.autoReload && deps.refreshSimulatorStyles()) {
+        deps.sendStatus('ready', '样式已热更新', false, pageList);
+        return;
+    }
+    deps.sendStatus('ready', deps.autoReload ? '编译完成，已重启' : '编译完成', deps.autoReload, pageList);
+}
+//# sourceMappingURL=rebuild-status.js.map

package/dist/main/services/workspace/session-status-store.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Authoritative, queryable record of the active project's compile status in
+ * the main process.
+ *
+ * `notify.projectStatus` is a fire-and-forget push to the renderer; MCP
+ * clients instead need to QUERY the latest state and AWAIT the next settled
+ * state. The notifier tap (see `status-tap.ts`) records every payload here
+ * BEFORE it is broadcast — the store is the authority, the renderer push is
+ * derived from the same single gate.
+ *
+ * "Settled" means the compile pipeline is not mid-flight: every phase except
+ * `'compiling'`. `generation` is a monotonic per-record counter so a waiter
+ * can ignore states recorded before its own trigger (e.g. `project_open`
+ * must not accept the PREVIOUS session's `'ready'` as its own result).
+ */
+export type SessionPhase = 'idle' | 'compiling' | 'ready' | 'error';
+export interface SessionStatusSnapshot {
+    phase: SessionPhase;
+    message: string;
+    /** False once the file watcher died mid-session (saves no longer trigger a rebuild). Reset when the next compile starts. */
+    watcherAlive: boolean;
+    /** Wall-clock time of the last recorded transition; 0 before the first one. */
+    updatedAt: number;
+    /** Monotonic counter bumped on every record. */
+    generation: number;
+}
+export interface SessionStatusStore {
+    get(): SessionStatusSnapshot;
+    /** Record one `projectStatus` payload (the notifier tap is the only expected caller). */
+    record(payload: {
+        status: string;
+        message: string;
+        watcher?: 'dead';
+    }): void;
+    /**
+     * Resolve with the first snapshot whose phase is settled (not 'compiling')
+     * AND whose generation is greater than `afterGeneration` (default: accept
+     * the current snapshot when it is already settled). Rejects after
+     * `timeoutMs` with the last observed phase in the message.
+     */
+    waitForSettled(opts: {
+        afterGeneration?: number;
+        timeoutMs: number;
+    }): Promise<SessionStatusSnapshot>;
+}
+export declare function createSessionStatusStore(): SessionStatusStore;
+//# sourceMappingURL=session-status-store.d.ts.map

package/dist/main/services/workspace/session-status-store.js

@@ -0,0 +1,73 @@
+/**
+ * Authoritative, queryable record of the active project's compile status in
+ * the main process.
+ *
+ * `notify.projectStatus` is a fire-and-forget push to the renderer; MCP
+ * clients instead need to QUERY the latest state and AWAIT the next settled
+ * state. The notifier tap (see `status-tap.ts`) records every payload here
+ * BEFORE it is broadcast — the store is the authority, the renderer push is
+ * derived from the same single gate.
+ *
+ * "Settled" means the compile pipeline is not mid-flight: every phase except
+ * `'compiling'`. `generation` is a monotonic per-record counter so a waiter
+ * can ignore states recorded before its own trigger (e.g. `project_open`
+ * must not accept the PREVIOUS session's `'ready'` as its own result).
+ */
+function toPhase(status) {
+    if (status === 'compiling')
+        return 'compiling';
+    if (status === 'error')
+        return 'error';
+    // 'ready' plus any future non-error chatter: the pipeline is not mid-flight.
+    return 'ready';
+}
+export function createSessionStatusStore() {
+    let snapshot = {
+        phase: 'idle',
+        message: '',
+        watcherAlive: true,
+        updatedAt: 0,
+        generation: 0,
+    };
+    const waiters = new Set();
+    return {
+        get: () => snapshot,
+        record(payload) {
+            const phase = toPhase(payload.status);
+            snapshot = {
+                phase,
+                message: payload.message,
+                // A dead watcher is a session-lifetime fact; only a NEW compile
+                // (fresh open) resets it. Rebuild 'ready' chatter keeps it dead.
+                watcherAlive: payload.watcher === 'dead'
+                    ? false
+                    : phase === 'compiling' ? true : snapshot.watcherAlive,
+                updatedAt: Date.now(),
+                generation: snapshot.generation + 1,
+            };
+            for (const waiter of [...waiters])
+                waiter(snapshot);
+        },
+        waitForSettled({ afterGeneration = -1, timeoutMs }) {
+            const isSettled = (s) => s.phase !== 'compiling' && s.generation > afterGeneration;
+            if (isSettled(snapshot))
+                return Promise.resolve(snapshot);
+            return new Promise((resolve, reject) => {
+                const timer = setTimeout(() => {
+                    waiters.delete(onRecord);
+                    reject(new Error(`timed out after ${timeoutMs}ms waiting for the compile to settle `
+                        + `(last phase: ${snapshot.phase})`));
+                }, timeoutMs);
+                const onRecord = (s) => {
+                    if (!isSettled(s))
+                        return;
+                    clearTimeout(timer);
+                    waiters.delete(onRecord);
+                    resolve(s);
+                };
+                waiters.add(onRecord);
+            });
+        },
+    };
+}
+//# sourceMappingURL=session-status-store.js.map

package/dist/main/services/workspace/status-tap.d.ts

@@ -0,0 +1,20 @@
+import type { RendererNotifier } from '../notifications/renderer-notifier.js';
+import type { CompileLogBuffer } from './compile-log-buffer.js';
+import type { SessionStatusStore } from './session-status-store.js';
+/**
+ * Wraps the renderer notifier so the two compile-state pushes ALSO land in
+ * the main-process authorities (session-status store + compile-log buffer)
+ * before the renderer broadcast.
+ *
+ * `ctx.notify` is the single outlet every status transition and log line
+ * already flows through (`workspace-service`'s `sendStatus` / `onLog`
+ * closures), so tapping at this gate keeps ONE bookkeeping site instead of a
+ * second call next to every producer — and the stale-session generation
+ * guard upstream of the notify call protects the store/buffer for free.
+ *
+ * A fresh open (`'compiling'` without `hotReload`) starts a new compile
+ * timeline, so it clears the buffer; watcher rebuilds never pass through
+ * `'compiling'` and keep appending to the same timeline.
+ */
+export declare function tapNotifierIntoStores(notify: RendererNotifier, status: SessionStatusStore, compileLogs: CompileLogBuffer): RendererNotifier;
+//# sourceMappingURL=status-tap.d.ts.map

package/dist/main/services/workspace/status-tap.js

@@ -0,0 +1,32 @@
+/**
+ * Wraps the renderer notifier so the two compile-state pushes ALSO land in
+ * the main-process authorities (session-status store + compile-log buffer)
+ * before the renderer broadcast.
+ *
+ * `ctx.notify` is the single outlet every status transition and log line
+ * already flows through (`workspace-service`'s `sendStatus` / `onLog`
+ * closures), so tapping at this gate keeps ONE bookkeeping site instead of a
+ * second call next to every producer — and the stale-session generation
+ * guard upstream of the notify call protects the store/buffer for free.
+ *
+ * A fresh open (`'compiling'` without `hotReload`) starts a new compile
+ * timeline, so it clears the buffer; watcher rebuilds never pass through
+ * `'compiling'` and keep appending to the same timeline.
+ */
+export function tapNotifierIntoStores(notify, status, compileLogs) {
+    return {
+        ...notify,
+        projectStatus(payload) {
+            if (payload.status === 'compiling' && payload.hotReload !== true) {
+                compileLogs.clear();
+            }
+            status.record(payload);
+            notify.projectStatus(payload);
+        },
+        compileLog(payload) {
+            compileLogs.append(payload);
+            notify.compileLog(payload);
+        },
+    };
+}
+//# sourceMappingURL=status-tap.js.map

package/dist/main/services/workspace/workspace-compile-modes.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Wires a `CompileModeStore` into `WorkspaceService` for whichever project is
+ * currently open. Extracted out of workspace-service.ts to keep that file
+ * under the repo's file-length ratchet — this is the sole owner of the
+ * store's lifecycle (open/replace/dispose); `WorkspaceService` only forwards
+ * to it.
+ */
+import { type CompileModeCommand } from '../../../shared/compile-mode-state.js';
+import type { CompileConfig } from '../../../shared/types.js';
+import type { ProjectsProvider } from '../projects/types.js';
+import { type CompileModeChange, type CompileModeSnapshot, type CompileModeStore } from './compile-mode-store.js';
+export interface CompileModeManager {
+    /**
+     * Creates and returns a store for `projectPath` as a standalone handle —
+     * it does NOT touch the current store or subscribe to `onChange`. The
+     * caller owns the handle until it either passes it to `adopt` or disposes
+     * it itself (e.g. because the open it belongs to was superseded).
+     */
+    open(projectPath: string): Promise<CompileModeStore>;
+    /**
+     * Makes `store` the current one: disposes whatever was current (and its
+     * subscription) first, then wires `store` up. The current store must only
+     * ever change here, alongside the session it belongs to — never as a side
+     * effect of merely opening one.
+     */
+    adopt(store: CompileModeStore): void;
+    /** Disposes the current store, if any. Safe to call when none is open. */
+    disposeCurrent(): void;
+    /**
+     * `projectPath` omitted returns the currently open project's snapshot
+     * (for callers, like the popover, that don't track a project path of
+     * their own); given, it must match the open store's project or this
+     * throws — a caller that DOES know the path never silently reads another
+     * project's modes.
+     */
+    getCompileModeState(projectPath?: string): CompileModeSnapshot;
+    applyCompileModeCommand(command: CompileModeCommand): Promise<CompileModeChange>;
+    getCompileConfig(projectPath: string): Promise<CompileConfig>;
+    /** Untouched by the store redesign — a direct provider passthrough. */
+    saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
+}
+export declare function createCompileModeManager(provider: ProjectsProvider, onChange: (change: CompileModeChange) => void): CompileModeManager;
+/**
+ * Opens a store handle for `projectPath` right after a compile succeeds,
+ * WITHOUT making it current — the caller decides whether to `adopt` it once
+ * it has confirmed (under the op lock) that its open is still the latest
+ * one; a superseded open disposes the handle itself instead. On failure,
+ * closes `session` (best-effort) and returns the error message. A session
+ * that compiled but whose store failed to open must not be left running, so
+ * this centralizes that cleanup for callers.
+ */
+export declare function openCompileModeStoreAfterCompile(manager: CompileModeManager, projectPath: string, session: {
+    close(): Promise<void>;
+}): Promise<{
+    store: CompileModeStore;
+} | {
+    error: string;
+}>;
+//# sourceMappingURL=workspace-compile-modes.d.ts.map

package/dist/main/services/workspace/workspace-compile-modes.js

@@ -0,0 +1,93 @@
+/**
+ * Wires a `CompileModeStore` into `WorkspaceService` for whichever project is
+ * currently open. Extracted out of workspace-service.ts to keep that file
+ * under the repo's file-length ratchet — this is the sole owner of the
+ * store's lifecycle (open/replace/dispose); `WorkspaceService` only forwards
+ * to it.
+ */
+import { selectedMode } from '../../../shared/compile-mode-state.js';
+import { compileConfigFromMode } from '../../../shared/compile-modes.js';
+import * as repo from '../projects/project-repository.js';
+import { createCompileModeAdapter } from './compile-mode-adapter.js';
+import { openCompileModeStore, } from './compile-mode-store.js';
+export function createCompileModeManager(provider, onChange) {
+    const adapter = createCompileModeAdapter(provider);
+    let store = null;
+    let unsubscribe = null;
+    function disposeCurrent() {
+        unsubscribe?.();
+        unsubscribe = null;
+        store?.dispose();
+        store = null;
+    }
+    async function open(projectPath) {
+        return openCompileModeStore({
+            projectPath,
+            load: () => adapter.getCompileModes(projectPath),
+            persist: (stored) => adapter.saveCompileModes(projectPath, stored),
+        });
+    }
+    function adopt(handle) {
+        disposeCurrent();
+        store = handle;
+        unsubscribe = handle.onChange(onChange);
+    }
+    function getCompileModeState(projectPath) {
+        if (!store || (projectPath !== undefined && projectPath !== store.projectPath)) {
+            throw new Error(`no compile-mode store open for ${projectPath ?? ''}`);
+        }
+        return store.get();
+    }
+    function applyCompileModeCommand(command) {
+        if (!store)
+            return Promise.reject(new Error('no compile-mode store open'));
+        return store.apply(command);
+    }
+    // Mirrors project-repository.ts's own getCompileConfig: 普通编译 (and any
+    // selected mode that left its start page blank) resolves to an empty
+    // startPage, filled in here with the project's real entry page rather than
+    // a mini-program-only literal.
+    async function getCompileConfig(projectPath) {
+        if (store && store.projectPath === projectPath) {
+            const config = compileConfigFromMode(selectedMode(store.get().state));
+            if (config.startPage)
+                return config;
+            return { ...config, startPage: repo.getProjectPages(projectPath).entryPagePath };
+        }
+        return adapter.getCompileConfig(projectPath);
+    }
+    return {
+        open,
+        adopt,
+        disposeCurrent,
+        getCompileModeState,
+        applyCompileModeCommand,
+        getCompileConfig,
+        saveCompileConfig: adapter.saveCompileConfig,
+    };
+}
+/**
+ * Opens a store handle for `projectPath` right after a compile succeeds,
+ * WITHOUT making it current — the caller decides whether to `adopt` it once
+ * it has confirmed (under the op lock) that its open is still the latest
+ * one; a superseded open disposes the handle itself instead. On failure,
+ * closes `session` (best-effort) and returns the error message. A session
+ * that compiled but whose store failed to open must not be left running, so
+ * this centralizes that cleanup for callers.
+ */
+export async function openCompileModeStoreAfterCompile(manager, projectPath, session) {
+    try {
+        const store = await manager.open(projectPath);
+        return { store };
+    }
+    catch (err) {
+        try {
+            await session.close();
+        }
+        catch (closeErr) {
+            console.warn('[workspace] closing session after compile-mode store open failure (non-fatal):', closeErr);
+        }
+        return { error: err instanceof Error ? err.message : String(err) };
+    }
+}
+//# sourceMappingURL=workspace-compile-modes.js.map

package/dist/main/services/workspace/workspace-lifecycle-race.testutil.d.ts

@@ -0,0 +1,22 @@
+import { vi } from 'vitest';
+type WorkbenchContext = Parameters<typeof import('./workspace-service.js').createWorkspaceService>[0];
+export declare function stubProjectsProvider(): import('../projects/types.js').ProjectsProvider;
+export declare function makeViewsSpy(): {
+    views: {
+        disposeAll: import("vitest").Mock<() => void>;
+        holdWorkbenchAttach: import("vitest").Mock<() => (() => void)>;
+        cancelWorkbenchAttachHold: import("vitest").Mock<() => void>;
+        disposeProjectViews: import("vitest").Mock<() => void>;
+        detachWorkbench: import("vitest").Mock<() => void>;
+        detachSimulator: import("vitest").Mock<() => void>;
+    };
+    events: string[];
+};
+export declare function makeCtxWith(views: ReturnType<typeof makeViewsSpy>['views'], adapter: {
+    openProject: ReturnType<typeof vi.fn>;
+}): WorkbenchContext;
+export declare function makeClosingHarness(closeBehavior: () => Promise<void>): {
+    ctx: WorkbenchContext;
+};
+export {};
+//# sourceMappingURL=workspace-lifecycle-race.testutil.d.ts.map

package/dist/main/services/workspace/workspace-lifecycle-race.testutil.js

@@ -0,0 +1,62 @@
+// Shared harness for the workspace-service concurrent-lifecycle suites
+// (workspace-lifecycle-race.test.ts): spy-instrumented views, minimal
+// WorkbenchContext stubs, and a close-behavior harness for the isClosing
+// tests. Pure vi.fn factories — the electron/fs/module mocks stay in the
+// test file (vi.mock is hoisted per test module and cannot live here).
+import { vi } from 'vitest';
+export function stubProjectsProvider() {
+    return {
+        listProjects: vi.fn(() => []),
+        addProject: vi.fn((p) => ({ name: 'fake', path: p, lastOpened: null })),
+        removeProject: vi.fn(),
+    };
+}
+export function makeViewsSpy() {
+    const events = [];
+    const views = {
+        disposeAll: vi.fn(() => { events.push('views.disposeAll'); }),
+        holdWorkbenchAttach: vi.fn(() => vi.fn()),
+        cancelWorkbenchAttachHold: vi.fn(() => { }),
+        // Project-scoped teardown: closeProject must call THIS, never disposeAll
+        // (which would also kill the host toolbar — see view-manager-dispose-scopes.test.ts).
+        disposeProjectViews: vi.fn(() => { events.push('views.disposeProjectViews'); }),
+        detachWorkbench: vi.fn(() => { events.push('views.detachWorkbench'); }),
+        detachSimulator: vi.fn(() => { events.push('views.detachSimulator'); }),
+    };
+    return { views, events };
+}
+export function makeCtxWith(views, adapter) {
+    return {
+        adapter,
+        notify: { projectStatus: vi.fn(), compileLog: vi.fn() },
+        views,
+        projectsProvider: stubProjectsProvider(),
+    };
+}
+// Minimal harness for the isClosing tests: sessions whose close() calls the given behavior.
+export function makeClosingHarness(closeBehavior) {
+    const adapter = {
+        openProject: vi.fn(async ({ projectPath }) => ({
+            port: 7788,
+            appInfo: { appId: `app:${projectPath}` },
+            close: vi.fn(closeBehavior),
+        })),
+    };
+    const views = {
+        disposeAll: vi.fn(),
+        holdWorkbenchAttach: vi.fn(() => vi.fn()),
+        cancelWorkbenchAttachHold: vi.fn(() => { }),
+        disposeProjectViews: vi.fn(),
+        detachWorkbench: vi.fn(),
+        detachSimulator: vi.fn(),
+    };
+    return {
+        ctx: {
+            adapter,
+            notify: { projectStatus: vi.fn(), compileLog: vi.fn() },
+            views,
+            projectsProvider: stubProjectsProvider(),
+        },
+    };
+}
+//# sourceMappingURL=workspace-lifecycle-race.testutil.js.map

package/dist/main/services/workspace/workspace-referer.d.ts

@@ -0,0 +1,17 @@
+import type { ProjectSession } from '../../../shared/types.js';
+/**
+ * The forced `servicewechat.com` Referer is stored per project partition, so
+ * every workspace call must name the project it is acting for. Both helpers
+ * therefore take the session and project path explicitly: a workspace that
+ * reached for its own mutable `currentSession` after resetting it would clear
+ * nothing, and one that passed no project at all would be asking to wipe a
+ * partition that belongs to whichever project happens to be open elsewhere.
+ */
+/** Forces this project's Referer. No-op for a session without a usable appId. */
+export declare function applyRefererForSession(session: ProjectSession, projectPath: string): void;
+/**
+ * Clears only this project's own entry. Call BEFORE the caller resets its
+ * session/path state, otherwise there is no partition left to name.
+ */
+export declare function clearRefererForSession(session: ProjectSession | null, projectPath: string): void;
+//# sourceMappingURL=workspace-referer.d.ts.map

package/dist/main/services/workspace/workspace-referer.js

@@ -0,0 +1,26 @@
+import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
+/**
+ * The forced `servicewechat.com` Referer is stored per project partition, so
+ * every workspace call must name the project it is acting for. Both helpers
+ * therefore take the session and project path explicitly: a workspace that
+ * reached for its own mutable `currentSession` after resetting it would clear
+ * nothing, and one that passed no project at all would be asking to wipe a
+ * partition that belongs to whichever project happens to be open elsewhere.
+ */
+/** Forces this project's Referer. No-op for a session without a usable appId. */
+export function applyRefererForSession(session, projectPath) {
+    const appInfo = session.appInfo;
+    if (!appInfo || typeof appInfo.appId !== 'string' || appInfo.appId.length === 0)
+        return;
+    setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined, projectPath);
+}
+/**
+ * Clears only this project's own entry. Call BEFORE the caller resets its
+ * session/path state, otherwise there is no partition left to name.
+ */
+export function clearRefererForSession(session, projectPath) {
+    if (!session)
+        return;
+    clearSimulatorServicewechatReferer(session.appInfo.appId, projectPath);
+}
+//# sourceMappingURL=workspace-referer.js.map

package/dist/main/services/workspace/workspace-service.d.ts

@@ -1,6 +1,9 @@
-import type { AppInfo, CompileConfig, LaunchConfig, ProjectSession } from '../../../shared/types.js';
+import type { AppInfo, CompileConfig, ProjectSession } from '../../../shared/types.js';
+import type { CompileModeCommand } from '../../../shared/compile-mode-state.js';
+import type { CompileModeChange, CompileModeSnapshot } from './compile-mode-store.js';
 import type { WorkbenchContext } from '../workbench-context.js';
 import type { Project, ProjectPages, ProjectSettings } from '../projects/project-repository.js';
+import type { ProjectPatch } from '../projects/types.js';
 /**
  * Result returned to the renderer after `project:open` finishes.
  * Mirrors the previous inline shape in ipc/session.ts so no
@@ -28,6 +31,7 @@ export interface WorkspaceService {
     listProjects(): Promise<Project[]>;
     addProject(dirPath: string): Promise<Project>;
     removeProject(dirPath: string): Promise<void>;
+    updateProject(dirPath: string, patch: ProjectPatch): Promise<Project>;
     hasProject(dirPath: string): Promise<boolean>;
     validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;
@@ -55,12 +59,10 @@ export interface WorkspaceService {
     getProjectPages(projectPath: string): ProjectPages;
     getCompileConfig(projectPath: string): Promise<CompileConfig>;
     saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
+    getCompileModeState(projectPath?: string): CompileModeSnapshot;
+    applyCompileModeCommand(command: CompileModeCommand): Promise<CompileModeChange>;
     getProjectSettings(projectPath: string): ProjectSettings;
     updateProjectSettings(projectPath: string, patch: Partial<ProjectSettings>): void;
-    getLaunchConfigs(projectPath: string): Promise<LaunchConfig[]>;
-    saveLaunchConfigs(projectPath: string, configs: LaunchConfig[]): Promise<void>;
-    getActiveLaunchConfigId(projectPath: string): Promise<string | null>;
-    saveActiveLaunchConfigId(projectPath: string, id: string | null): Promise<void>;
 }
 /** Build a workspace service bound to the given workbench context. */
 export declare function createWorkspaceService(ctx: WorkbenchContext): WorkspaceService;