@dimina-kit/devtools 0.3.1-dev.20260517100756 → 0.3.1-dev.20260518114324

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

@@ -14,6 +14,7 @@ const DEFAULTS = {
         watch: true,
     },
     theme: 'system',
+    lastCreateBaseDir: null,
 };
 function getSettingsFile() {
     return path.join(app.getPath('userData'), 'dimina-workbench-settings.json');
@@ -37,6 +38,9 @@ export function loadWorkbenchSettings() {
                 watch: data.compile?.watch ?? DEFAULTS.compile.watch,
             },
             theme,
+            lastCreateBaseDir: typeof data.lastCreateBaseDir === 'string'
+                ? data.lastCreateBaseDir
+                : DEFAULTS.lastCreateBaseDir,
         };
     }
     catch {

package/dist/main/services/workbench-context.d.ts

@@ -6,6 +6,8 @@ import { type RendererNotifier } from './notifications/renderer-notifier.js';
 import { type ViewManager } from './views/view-manager.js';
 import { type WindowService } from './window-service.js';
 import { type WorkspaceService } from './workspace/workspace-service.js';
+import { sanitizeTemplates } from './projects/templates.js';
+import type { CreateProjectInput, ProjectsProvider, ProjectTemplate } from './projects/types.js';
 /**
  * Shared mutable state for the workbench application.
  * Passed to each IPC module so they can read/write shared state without closures.
@@ -48,6 +50,30 @@ export interface WorkbenchContext {
     notify: RendererNotifier;
     /** Single source of truth for project + session + per-project settings */
     workspace: WorkspaceService;
+    /**
+     * Pluggable backend for the project list. Defaults to a LocalProjectsProvider
+     * that persists to `<userData>/dimina-projects.json`. Hosts can inject a
+     * custom implementation (e.g. read from a remote workspace).
+     */
+    projectsProvider: ProjectsProvider;
+    /**
+     * Merged template catalog used by the create-project flow. Combines the
+     * built-in templates with `WorkbenchAppConfig.projectTemplates` according
+     * to `WorkbenchAppConfig.builtinTemplates`. Keeps any `generate`
+     * functions intact — for IPC delivery, `sanitizeTemplates` is applied at
+     * the IPC boundary.
+     */
+    projectTemplates: ProjectTemplate[];
+    /**
+     * Optional host hook for the "新建项目" dialog. When present, the
+     * `projects:openCreateDialog` IPC returns whatever this hook resolves to;
+     * when absent, the IPC returns null and the renderer shows the built-in
+     * dialog.
+     */
+    customCreateProjectDialog?: (ctx: {
+        parentWindow: BrowserWindow;
+        templates: ProjectTemplate[];
+    }) => Promise<CreateProjectInput | null>;
     /**
      * Trust predicate consulted by `IpcRegistry` for every incoming IPC.
      * Resolves the currently-trusted senders (main renderer + overlays)
@@ -67,8 +93,17 @@ export interface CreateContextOptions {
     appName?: string;
     toolbarActions?: WorkbenchContext['toolbarActions'];
     brandingProvider?: WorkbenchContext['brandingProvider'];
+    /** Host-supplied project list backend. Defaults to LocalProjectsProvider. */
+    projectsProvider?: ProjectsProvider;
+    /** Templates injected by the host; same-id overrides a built-in. */
+    projectTemplates?: ProjectTemplate[];
+    /** Built-in template policy (default 'all'). */
+    builtinTemplates?: 'all' | 'none' | readonly string[];
+    /** Host-supplied "新建项目" dialog hook. */
+    customCreateProjectDialog?: WorkbenchContext['customCreateProjectDialog'];
 }
 export declare function hasBuiltinPanel(ctx: Pick<WorkbenchContext, 'panels'>, panelId: string): boolean;
 export declare function getDefaultTab(ctx: Pick<WorkbenchContext, 'panels'>): string;
 export declare function createWorkbenchContext(opts: CreateContextOptions): WorkbenchContext;
+export { sanitizeTemplates };
 //# sourceMappingURL=workbench-context.d.ts.map

package/dist/main/services/workbench-context.js

@@ -5,6 +5,9 @@ import { createRendererNotifier, } from './notifications/renderer-notifier.js';
 import { createViewManager } from './views/view-manager.js';
 import { createWindowService } from './window-service.js';
 import { createWorkspaceService, } from './workspace/workspace-service.js';
+import { createLocalProjectsProvider } from './projects/local-provider.js';
+import { resolveTemplates, sanitizeTemplates } from './projects/templates.js';
+import { BUILTIN_TEMPLATES } from './projects/builtin-templates.js';
 export function hasBuiltinPanel(ctx, panelId) {
     return ctx.panels.includes(panelId);
 }
@@ -32,8 +35,14 @@ export function createWorkbenchContext(opts) {
     ctx.windows = createWindowService(ctx.mainWindow);
     ctx.views = createViewManager(ctx);
     ctx.notify = createRendererNotifier(ctx);
+    ctx.projectsProvider = opts.projectsProvider ?? createLocalProjectsProvider();
+    ctx.projectTemplates = resolveTemplates(BUILTIN_TEMPLATES, opts.projectTemplates ?? [], opts.builtinTemplates ?? 'all');
+    ctx.customCreateProjectDialog = opts.customCreateProjectDialog;
     ctx.workspace = createWorkspaceService(ctx);
     ctx.senderPolicy = createWorkbenchSenderPolicy(ctx);
     return ctx;
 }
+// Re-export at this stable module path so callers don't have to know about
+// the projects/ subtree layout.
+export { sanitizeTemplates };
 //# sourceMappingURL=workbench-context.js.map

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

@@ -25,11 +25,11 @@ export interface OpenProjectResult {
  * rather than touching the repository or adapter directly.
  */
 export interface WorkspaceService {
-    listProjects(): Project[];
-    addProject(dirPath: string): Project;
-    removeProject(dirPath: string): void;
-    hasProject(dirPath: string): boolean;
-    validateProjectDir(dirPath: string): string | null;
+    listProjects(): Promise<Project[]>;
+    addProject(dirPath: string): Promise<Project>;
+    removeProject(dirPath: string): Promise<void>;
+    hasProject(dirPath: string): Promise<boolean>;
+    validateProjectDir(dirPath: string): Promise<string | null>;
     openProject(projectPath: string): Promise<OpenProjectResult>;
     closeProject(): Promise<void>;
     getSession(): {
@@ -39,9 +39,11 @@ export interface WorkspaceService {
     } | null;
     getProjectPath(): string;
     hasActiveSession(): boolean;
+    captureThumbnail(projectPath: string): Promise<string | null>;
+    getThumbnail(projectPath: string): Promise<string | null>;
     getProjectPages(projectPath: string): ProjectPages;
-    getCompileConfig(projectPath: string): CompileConfig;
-    saveCompileConfig(projectPath: string, config: CompileConfig): void;
+    getCompileConfig(projectPath: string): Promise<CompileConfig>;
+    saveCompileConfig(projectPath: string, config: CompileConfig): Promise<void>;
     getProjectSettings(projectPath: string): ProjectSettings;
     updateProjectSettings(projectPath: string, patch: Partial<ProjectSettings>): void;
 }

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

@@ -1,4 +1,6 @@
+import { webContents } from 'electron';
 import * as repo from '../projects/project-repository.js';
+import { DEFAULT_COMPILE_CONFIG } from '../projects/types.js';
 import { clearSimulatorServicewechatReferer, setSimulatorServicewechatReferer, } from '../simulator/referer.js';
 import { loadWorkbenchSettings } from '../settings/index.js';
 /** Build a workspace service bound to the given workbench context. */
@@ -37,12 +39,37 @@ export function createWorkspaceService(ctx) {
             setSimulatorServicewechatReferer(appInfo.appId, typeof appInfo.version === 'string' ? appInfo.version : undefined);
         }
     }
-    return {
+    // Delegate to the host-injected (or default) ProjectsProvider on the
+    // context. When the host omits an optional method, we apply a safe
+    // documented default — never silently fall back to `repo.*`, because a
+    // remote provider's project paths are not on the local filesystem.
+    //
+    // The `??` here is a back-compat path for hand-rolled WorkbenchContext
+    // values (used in a couple of legacy tests). createWorkbenchContext
+    // always installs LocalProjectsProvider, so production never enters this
+    // branch.
+    const provider = ctx.projectsProvider ?? {
         listProjects: () => repo.listProjects(),
-        addProject: (dirPath) => repo.addProject(dirPath),
-        removeProject: (dirPath) => repo.removeProject(dirPath),
-        hasProject: (dirPath) => repo.hasProject(dirPath),
-        validateProjectDir: (dirPath) => repo.validateProjectDir(dirPath),
+        addProject: (p) => repo.addProject(p),
+        removeProject: (p) => repo.removeProject(p),
+        validateProjectDir: (p) => repo.validateProjectDir(p),
+        updateLastOpened: (p) => repo.updateLastOpened(p),
+        getCompileConfig: (p) => repo.getCompileConfig(p),
+        saveCompileConfig: (p, c) => repo.saveCompileConfig(p, c),
+    };
+    return {
+        listProjects: async () => provider.listProjects(),
+        addProject: async (dirPath) => provider.addProject(dirPath),
+        removeProject: async (dirPath) => {
+            await provider.removeProject(dirPath);
+        },
+        hasProject: async (dirPath) => {
+            const projects = await provider.listProjects();
+            return projects.some((p) => p.path === dirPath);
+        },
+        validateProjectDir: async (dirPath) => provider.validateProjectDir
+            ? provider.validateProjectDir(dirPath)
+            : null,
         async openProject(projectPath) {
             clearSimulatorServicewechatReferer();
             await disposeSession();
@@ -54,7 +81,9 @@ export function createWorkspaceService(ctx) {
             // `fetch(…).then(r=>r.text()).then(JSON.parse)` pipeline dies on the
             // dev server's HTML SPA fallback with
             // `SyntaxError: Unexpected token '<', "<!doctype "…`.
-            const dirError = repo.validateProjectDir(projectPath);
+            const dirError = provider.validateProjectDir
+                ? await provider.validateProjectDir(projectPath)
+                : null;
             if (dirError) {
                 sendStatus('error', dirError);
                 return { success: false, error: dirError };
@@ -78,7 +107,10 @@ export function createWorkspaceService(ctx) {
             }
             currentSession = session;
             currentProjectPath = projectPath;
-            bestEffort('updateLastOpened', () => repo.updateLastOpened(projectPath));
+            bestEffort('updateLastOpened', () => {
+                if (provider.updateLastOpened)
+                    provider.updateLastOpened(projectPath);
+            });
             bestEffort('sendStatus', () => sendStatus('ready', '编译完成'));
             bestEffort('applyReferer', () => applyRefererFromSession(session));
             return {
@@ -96,9 +128,49 @@ export function createWorkspaceService(ctx) {
         getSession: () => currentSession,
         getProjectPath: () => currentProjectPath,
         hasActiveSession: () => currentSession !== null,
+        async captureThumbnail(projectPath) {
+            const simWcId = ctx.views.getSimulatorWebContentsId();
+            if (!simWcId)
+                return null;
+            const wc = webContents.fromId(simWcId);
+            if (!wc || wc.isDestroyed())
+                return null;
+            try {
+                const image = await wc.capturePage();
+                const dataUrl = `data:image/png;base64,${image.toPNG().toString('base64')}`;
+                if (provider.saveThumbnail) {
+                    await provider.saveThumbnail(projectPath, dataUrl);
+                }
+                // Always hand the renderer back the freshly-captured frame so the
+                // UI updates immediately even if the host's saveThumbnail is
+                // async or stores out-of-band.
+                return dataUrl;
+            }
+            catch {
+                return null;
+            }
+        },
+        async getThumbnail(projectPath) {
+            if (provider.getThumbnail) {
+                return (await provider.getThumbnail(projectPath)) ?? null;
+            }
+            return null;
+        },
+        // `getProjectPages` reads the project's own `app.json` from disk and is
+        // independent of the project registry — it stays on the repo helper.
         getProjectPages: (projectPath) => repo.getProjectPages(projectPath),
-        getCompileConfig: (projectPath) => repo.getCompileConfig(projectPath),
-        saveCompileConfig: (projectPath, config) => repo.saveCompileConfig(projectPath, config),
+        getCompileConfig: async (projectPath) => (provider.getCompileConfig
+            ? await provider.getCompileConfig(projectPath)
+            : DEFAULT_COMPILE_CONFIG),
+        saveCompileConfig: async (projectPath, config) => {
+            if (provider.saveCompileConfig) {
+                await provider.saveCompileConfig(projectPath, config);
+            }
+            // No persistence when the host opts out; the renderer's edits then
+            // do not survive a reload, matching the documented contract.
+        },
+        // Per-project settings (uploadWithSourceMap etc.) live in the project's
+        // own `project.config.json`, not the registry — keep direct repo calls.
         getProjectSettings: (projectPath) => repo.getProjectSettings(projectPath),
         updateProjectSettings: (projectPath, patch) => repo.updateProjectSettings(projectPath, patch),
     };

package/dist/main/utils/sender-policy.d.ts

@@ -10,11 +10,13 @@ import type { SenderPolicy } from './ipc-registry.js';
  * - the settings overlay view (when open)
  * - the popover overlay view (when open)
  *
- * The simulator webview is intentionally NOT on this list: its preload
- * (`src/preload/windows/simulator.ts`) uses `ipcRenderer.sendToHost`
- * exclusively, never `invoke`/`send`, so it can't legitimately reach an
- * ipcMain handler. Including it would only widen the attack surface if
- * the guest were ever compromised.
+ * The simulator webview is intentionally NOT on this list. Anything it
+ * needs from main (currently just the custom-apis bridge — see
+ * `installCustomApisBridge` in `src/preload/runtime/custom-apis.ts` and the
+ * matching `useCustomApiProxy` host hook) proxies through the trusted
+ * main-window renderer via `ipcRenderer.sendToHost` + `<webview>.send`.
+ * Keeping the guest off this list contains the blast radius if the
+ * simulator content is ever compromised.
  *
  * Any other sender — including a stale/destroyed sender or an unknown
  * iframe — is rejected.

package/dist/main/utils/sender-policy.js

@@ -8,11 +8,13 @@
  * - the settings overlay view (when open)
  * - the popover overlay view (when open)
  *
- * The simulator webview is intentionally NOT on this list: its preload
- * (`src/preload/windows/simulator.ts`) uses `ipcRenderer.sendToHost`
- * exclusively, never `invoke`/`send`, so it can't legitimately reach an
- * ipcMain handler. Including it would only widen the attack surface if
- * the guest were ever compromised.
+ * The simulator webview is intentionally NOT on this list. Anything it
+ * needs from main (currently just the custom-apis bridge — see
+ * `installCustomApisBridge` in `src/preload/runtime/custom-apis.ts` and the
+ * matching `useCustomApiProxy` host hook) proxies through the trusted
+ * main-window renderer via `ipcRenderer.sendToHost` + `<webview>.send`.
+ * Keeping the guest off this list contains the blast radius if the
+ * simulator content is ever compromised.
  *
  * Any other sender — including a stale/destroyed sender or an unknown
  * iframe — is rejected.
@@ -35,7 +37,7 @@ export function createWorkbenchSenderPolicy(ctx) {
         const popoverViewId = ctx.views.getPopoverWebContentsId();
         if (popoverViewId != null && sender.id === popoverViewId)
             return true;
-        // simulator preload uses sendToHost only; never reaches ipcMain handlers.
+        // simulator <webview> proxies through main-window renderer (see file header).
         return false;
     };
 }

package/dist/main/windows/main-window/create.js

@@ -29,7 +29,7 @@ function configureSimulatorSession(simulatorPreloadPath) {
         headers['access-control-allow-headers'] = ['*'];
         headers['access-control-allow-methods'] = ['*'];
         headers['Cross-Origin-Opener-Policy'] = ['same-origin'];
-        headers['Cross-Origin-Embedder-Policy'] = ['require-corp'];
+        headers['Cross-Origin-Embedder-Policy'] = ['credentialless'];
         callback({ responseHeaders: headers });
     });
 }

package/dist/preload/runtime/custom-apis.js

@@ -1,9 +1,38 @@
 import { contextBridge, ipcRenderer } from 'electron';
-import { SimulatorCustomApiChannel } from '../../shared/ipc-channels.js';
+import { SimulatorCustomApiBridgeChannel } from '../../shared/ipc-channels.js';
+// The simulator <webview> is intentionally kept off the workbench sender-policy
+// white-list, so it cannot reach `ipcMain.handle` directly. Instead the bridge
+// asks the trusted main-window renderer to proxy the call: webview sends via
+// `ipcRenderer.sendToHost`, host does the `ipcInvoke`, and posts the result
+// back through `<webview>.send`. Requests and responses are correlated by id
+// so concurrent invokes do not tangle.
 function buildBridge() {
+    let nextId = 1;
+    const pending = new Map();
+    ipcRenderer.on(SimulatorCustomApiBridgeChannel.Response, (_event, payload) => {
+        const entry = pending.get(payload.id);
+        if (!entry)
+            return;
+        pending.delete(payload.id);
+        if ('error' in payload) {
+            entry.reject(new Error(payload.error));
+        }
+        else {
+            entry.resolve(payload.result);
+        }
+    });
+    const send = (req) => {
+        return new Promise((resolve, reject) => {
+            pending.set(req.id, {
+                resolve: (value) => resolve(value),
+                reject,
+            });
+            ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
+        });
+    };
     return {
-        list: () => ipcRenderer.invoke(SimulatorCustomApiChannel.List),
-        invoke: (name, params) => ipcRenderer.invoke(SimulatorCustomApiChannel.Invoke, name, params),
+        list: () => send({ id: nextId++, op: 'list' }),
+        invoke: (name, params) => send({ id: nextId++, op: 'invoke', name, params }),
     };
 }
 export function installCustomApisBridge() {

package/dist/preload/windows/simulator.js

@@ -187,9 +187,9 @@ var SimulatorChannel = {
   AppData: "simulator:appdata",
   AppDataAll: "simulator:appdata-all"
 };
-var SimulatorCustomApiChannel = {
-  List: "simulator:custom-apis:list",
-  Invoke: "simulator:custom-apis:invoke"
+var SimulatorCustomApiBridgeChannel = {
+  Request: "simulator:custom-apis:bridge-request",
+  Response: "simulator:custom-apis:bridge-response"
 };
 var BridgeChannel = {
   WxmlRefreshRequest: "wxml:refresh:request",
@@ -199,9 +199,30 @@ var BridgeChannel = {
 
 // src/preload/runtime/custom-apis.ts
 function buildBridge() {
+  let nextId = 1;
+  const pending = /* @__PURE__ */ new Map();
+  import_electron2.ipcRenderer.on(SimulatorCustomApiBridgeChannel.Response, (_event, payload) => {
+    const entry = pending.get(payload.id);
+    if (!entry) return;
+    pending.delete(payload.id);
+    if ("error" in payload) {
+      entry.reject(new Error(payload.error));
+    } else {
+      entry.resolve(payload.result);
+    }
+  });
+  const send = (req) => {
+    return new Promise((resolve, reject) => {
+      pending.set(req.id, {
+        resolve: (value) => resolve(value),
+        reject
+      });
+      import_electron2.ipcRenderer.sendToHost(SimulatorCustomApiBridgeChannel.Request, req);
+    });
+  };
   return {
-    list: () => import_electron2.ipcRenderer.invoke(SimulatorCustomApiChannel.List),
-    invoke: (name, params) => import_electron2.ipcRenderer.invoke(SimulatorCustomApiChannel.Invoke, name, params)
+    list: () => send({ id: nextId++, op: "list" }),
+    invoke: (name, params) => send({ id: nextId++, op: "invoke", name, params })
   };
 }
 function installCustomApisBridge() {